--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/homescreenpluginsrv/hspsmanager/src/hspsthemeserver.cpp Wed Sep 01 12:22:09 2010 +0100
@@ -0,0 +1,3718 @@
+/*
+* 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
+ TRAP_IGNORE( 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__)
+
+ // These might leave if configurations are invalid
+ TRAP_IGNORE( InitializeHeadersL() );
+
+ // 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
+ }
+
+void ChspsThemeServer::InitializeHeadersL()
+ {
+ // Auto-localize ODTs in the Definition Repository when the device language has changed
+ HandleLanguageChangeL();
+
+ // Reinstall plug-ins/handle FOTA updates
+ HandleRomInstallationsL();
+
+#ifndef __DISABLE_SISX_INSTALLATION_
+ // Start observing of import folder to enable autoinstallations
+ EnableAutoInstallationL();
+#endif //__DISABLE_SISX_INSTALLATION_
+ }
+
+// 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 )
+ {
+ if( aSession == NULL )
+ {
+ return;
+ }
+
+ iSessions.Append( aSession );
+
+#ifdef _hsps_SERVER_SHUTDOWN_ENABLED_
+ if( iShutdown->IsActive() )
+ {
+ iShutdown->Cancel();
+ }
+#endif // _hsps_SERVER_SHUTDOWN_ENABLED_
+
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::AddSession(): - now %d concurrent sessions." ),
+ iSessions.Count() );
+#endif
+ }
+
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::DropSession
+// A session is being destroyed
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::DropSession( ChspsThemeServerSession* aSession )
+ {
+ const TInt index = iSessions.Find( aSession );
+ if( index != KErrNotFound )
+ {
+ iSessions.Remove( index );
+ }
+
+#ifdef _hsps_SERVER_SHUTDOWN_ENABLED_
+ if( iSessions.Count() == 0 )
+ {
+ iShutdown->Cancel();
+ iShutdown->Start();
+ }
+#endif // _hsps_SERVER_SHUTDOWN_ENABLED_
+
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::DropSession(): - %d concurrent sessions left." ),
+ iSessions.Count() );
+#endif
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::IncreaseRequestClientCount
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::IncreaseRequestClientCount()
+ {
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer: ChspsThemeServer::IncreaseRequestClientCount()" ) );
+#endif
+
+ iRequestClientCount++;
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::DecreaseRequestClientCount
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::DecreaseRequestClientCount()
+ {
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer: ChspsThemeServer::DecreaseRequestClientCount()" ) );
+#endif
+
+ if ( iRequestClientCount )
+ {
+ iRequestClientCount--;
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::HandleDefinitionRespositoryEvent()
+// Handles events coming from hspsDefinitionRepository.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TBool ChspsThemeServer::HandleDefinitionRespositoryEvent( ThspsRepositoryInfo aRepositoryInfo )
+ {
+ TInt mask = aRepositoryInfo.iEventType;
+ TBool ret = EFalse;
+
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "--------------------------------------------------------" ) );
+#endif
+
+ if( aRepositoryInfo.iEventType & EhspsODTUpdated ||
+ aRepositoryInfo.iEventType & EhspsODTModified ||
+ aRepositoryInfo.iEventType & EhspsPluginReplaced )
+ {
+ SetResourceFileCopyRequired( aRepositoryInfo.iAppUid );
+ }
+
+ // If header cache should be updated from files in the Plug-in Repository
+ if (mask & EhspsCacheUpdate)
+ {
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::HandleDefinitionRespositoryEvent(): - EhspsCacheUpdate occurred." ) );
+#endif
+ // Update the cache from contents of the themes folder in drive C (slowish operation!)
+ TRAP_IGNORE( UpdateHeaderListCacheL() );
+ }
+
+ // If a plug-in configuration was uninstalled from the Plug-in Repository
+ if (mask & EhspsClean)
+ {
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::HandleDefinitionRespositoryEvent(): - EhspsClean occurred." ) );
+#endif
+ if(aRepositoryInfo.iLastNotification)
+ {
+ // Remove the provided ODT from the header list cache
+ UpdateHeaderListCache(
+ EhspsCacheRemoveHeader,
+ aRepositoryInfo.iPluginIfUid,
+ aRepositoryInfo.iPluginProviderUid,
+ aRepositoryInfo.iPluginUid
+ );
+ }
+
+ }
+
+ // If a plug-in configuration was installed into the Plug-in Repository
+ if (mask & EhspsODTAdded)
+ {
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::HandleDefinitionRespositoryEvent(): - EhspsODTAdded occurred." ) );
+#endif
+ if(aRepositoryInfo.iLastNotification)
+ {
+ // Add the provided ODT to the header list cache
+ UpdateHeaderListCache(
+ EhspsCacheAddHeader,
+ aRepositoryInfo.iPluginIfUid,
+ aRepositoryInfo.iPluginProviderUid,
+ aRepositoryInfo.iPluginUid
+ );
+ }
+
+ }
+
+ // If a plug-in configuration was upgraded into the Plug-in Repository
+ if( mask & EhspsODTUpdated )
+ {
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::HandleDefinitionRespositoryEvent(): - EhspsODTUpdate occurred." ) );
+#endif
+ if( aRepositoryInfo.iLastNotification )
+ {
+ // Add the provided ODT to the header list cache
+ UpdateHeaderListCache(
+ EhspsCacheAddHeader,
+ aRepositoryInfo.iPluginIfUid,
+ aRepositoryInfo.iPluginProviderUid,
+ aRepositoryInfo.iPluginUid
+ );
+ }
+ }
+
+ // If settings of an application configuration were modified
+ if (mask & EhspsSettingsChanged)
+ {
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::HandleDefinitionRespositoryEvent(): - EhspsSettingsChanged occurred." ) );
+#endif
+ }
+
+ // If a plug-in configuration was added into or moved within an application configuration
+ if (mask & EhspsODTModified)
+ {
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::HandleDefinitionRespositoryEvent(): - EhspsODTModified occured." ) );
+#endif
+ }
+
+ // If a plug-in configuration was removed from an application configuration
+ if (mask & EhspsODTRemoved)
+ {
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::HandleDefinitionRespositoryEvent(): - EhspsODTRemoved occurred." ) );
+#endif
+ }
+
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "--------------------------------------------------------" ) );
+#endif
+
+ return ret;
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::DefinitionRepository
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+ChspsDefinitionRepository& ChspsThemeServer::DefinitionRepository()
+ {
+ return *iDefinitionRepository;
+ }
+
+// ChspsThemeServer::SecurityEnforcer
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+ChspsSecurityEnforcer& ChspsThemeServer::SecurityEnforcer()
+ {
+ return *iSecurityEnforcer;
+ }
+
+
+// ChspsThemeServer::CentralRepository
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+CRepository& ChspsThemeServer::CentralRepository()
+ {
+ return *iCentralRepository;
+ }
+
+// ChspsThemeServer::DeviceLaguage
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TLanguage ChspsThemeServer::DeviceLanguage()
+ {
+ iDeviceLanguage = GetDeviceLanguage();
+ return iDeviceLanguage;
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::UpdateHeaderListCache
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+CArrayPtrSeg<ChspsODT>& ChspsThemeServer::HeaderListCache()
+ {
+ return *iHeaderListCache;
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::UninstallImport
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::UninstallImport(
+ const CDir* aFilelist )
+ {
+ TInt count( 0 );
+ if ( aFilelist )
+ {
+ count = aFilelist->Count();
+ }
+
+ // Loop installed configurations
+ for( TInt i = 0; i < iInstalledSisxThemes.Count(); i++ )
+ {
+ // Suppose this is the one which was removed
+ iThemeIndexToRemove = i;
+
+ // Loop files under the imports folder
+ for( TInt j = 0; j < count; j++ )
+ {
+ TPtrC filename( ( *aFilelist )[j].iName );
+
+ // If theme path exists
+ if( filename == *( iInstalledSisxThemes[i] ) )
+ {
+ // Break inner loop
+ iThemeIndexToRemove = KErrNotFound;
+ break;
+ }
+ }
+
+ // iThemeIndexToRemove should now point the configuration which was removed
+ RunAutoInstaller( EAutoInstallerUninstall );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::GetManifestFromImportLC
+// -----------------------------------------------------------------------------
+//
+HBufC* ChspsThemeServer::GetManifestFromImportLC(
+ const TDesC& aImportFile,
+ const TDesC& aPath )
+ {
+ HBufC* manifestBuf = 0;
+
+ const TChar KCharUnderscore('_');
+
+ // Strip file prefix
+ TPtrC fixedName;
+ TInt offset = aImportFile.Locate( KCharUnderscore );
+ if( offset )
+ {
+ TPtrC filePrefix( aImportFile.Left(offset+1) );
+
+ // If a valid prefix
+ if ( filePrefix.CompareF( KPrefixFileApp) || filePrefix.CompareF( KPrefixFilePlugin ) )
+ {
+ fixedName.Set( aImportFile.Mid( filePrefix.Length() ) );
+ }
+ }
+
+ // If stripping was successfull
+ if ( fixedName.Length() )
+ {
+ // Remove file extension
+ TParsePtrC parsePtr( fixedName );
+ TPtrC fileName( parsePtr.Name() );
+
+ // Setup path for the manifest file
+ manifestBuf = HBufC::NewLC( KMaxFileName );
+ TPtr manifestPtr( manifestBuf->Des() );
+ manifestPtr.Append( aPath );
+ manifestPtr.Append( fileName );
+
+ // Replace underscores with backslashes
+ TInt pos( manifestPtr.Locate( KCharUnderscore ) );
+ while( pos != KErrNotFound )
+ {
+ manifestPtr.Replace( pos, 1, KDoubleBackSlash );
+ pos = manifestPtr.Locate( KCharUnderscore );
+ }
+ manifestPtr.Append( KDoubleBackSlash );
+
+ // Find a manifest.dat file from the generated path
+ CDir* manifestDir( NULL );
+ TFindFile fileFinder( iFsSession );
+ fileFinder.FindWildByDir( KManifestFile, manifestPtr, manifestDir );
+
+ // Check whether the manifest was found
+ if( !manifestDir || manifestDir->Count() > 1 )
+ {
+ // Failed
+ CleanupStack::PopAndDestroy( 1, manifestBuf );
+ manifestBuf = NULL;
+ }
+ else
+ {
+ manifestPtr.Append( KManifestFile );
+ }
+
+ delete manifestDir;
+ manifestDir = NULL;
+ }
+
+ return manifestBuf;
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::CheckConfiguration
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::CheckConfigurationL(
+ const TInt aAppUid )
+ {
+
+ if ( iHeaderListCache )
+ {
+ TInt count = iHeaderListCache->Count();
+ if ( iDefinitionRepository->Locked() )
+ {
+ User::Leave( KErrInUse );
+ }
+ iDefinitionRepository->Lock();
+
+ // Check if configuration checking is activated
+ TPtrC8 confState;
+ TPtrC8 nextConfState;
+ TInt value( 0 );
+ User::LeaveIfError( iCentralRepository->Get( KCenrepKeyCheckConf, value ) );
+ if ( value == 1 )
+ {
+ // Configuration checking activated
+ // All configurations with "WaitForConfiguration" state will be updated to
+ // "Error" state
+ confState.Set( KConfStateWaitForConfirmation );
+ nextConfState.Set( KConfStateError );
+ }
+ else
+ {
+ // Configuration checking not activated
+ // All configurations with "WaitForConfiguration" state will be updated to
+ // "NotConfirmed" state
+ confState.Set( KConfStateWaitForConfirmation );
+ nextConfState.Set( KConfStateNotConfirmed );
+ }
+
+ for ( TInt i = 0; i < count; i++ )
+ {
+ ChspsODT* header = ( *iHeaderListCache )[ i ];
+ if ( header->ConfigurationType() == EhspsAppConfiguration &&
+ ( header->RootUid() == aAppUid ||
+ aAppUid == KAppIdAny ) )
+ {
+ // Get ODT from definition repository
+
+ ChspsODT* odt = ChspsODT::NewL();
+ CleanupStack::PushL( odt );
+ odt->SetRootUid( header->RootUid() );
+ odt->SetThemeUid( header->ThemeUid() );
+ odt->SetConfigurationType( header->ConfigurationType() );
+ odt->SetRootUid( header->RootUid() );
+ odt->SetProviderUid( header->ProviderUid() );
+ odt->SetThemeUid( header->ThemeUid() );
+ odt->SetProviderNameL( header->ProviderName() );
+ odt->SetThemeFullNameL( header->ThemeFullName() );
+ odt->SetThemeShortNameL( header->ThemeShortName() );
+ odt->SetThemeVersionL( header->ThemeVersion() );
+ odt->SetDescriptionL( header->Description() );
+ odt->SetFlags( header->Flags() );
+ odt->SetMultiInstance( header->MultiInstance() );
+
+ User::LeaveIfError( iDefinitionRepository->GetOdtL( *odt ) );
+
+ // Update configuration states
+ TBool odtUpdated( EFalse );
+ hspsServerUtil::UpdateConfigurationStateL(
+ *odt,
+ confState,
+ nextConfState,
+ odtUpdated );
+ if ( odtUpdated )
+ {
+ // Update modified ODT to definition repository
+ User::LeaveIfError( iDefinitionRepository->SetOdtL( *odt ) );
+ }
+
+ CleanupStack::PopAndDestroy( odt );
+ }
+ }
+ iDefinitionRepository->Unlock();
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::InstallImportsL
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::InstallImportsL(
+ const CDir& aFilelist )
+ {
+ const TInt count( aFilelist.Count() );
+
+ // Go through the filtered file list
+ for( TInt importIndex = 0; importIndex < count; importIndex++ )
+ {
+ TBool found( EFalse );
+ TPtrC importName( aFilelist[importIndex].iName );
+
+ // Is the file already pending an installation?
+ for( TInt j = 0; !found && j < iInstallableSisxThemes.Count(); j++ )
+ {
+ if( importName == *( iInstallableSisxThemes[j] ) )
+ {
+ found = ETrue;
+ }
+ }
+
+ // Is the file already installed?
+ for( TInt j = 0; !found && j < iInstalledSisxThemes.Count(); j++ )
+ {
+ if( importName == *( iInstalledSisxThemes[j] ) )
+ {
+ found = ETrue;
+ }
+ }
+
+ if ( !found )
+ {
+ // Get manifest from the import's name in C drive
+ HBufC* manifestBuf = GetManifestFromImportLC(
+ importName,
+ KImportDirectoryC );
+ if( manifestBuf )
+ {
+ // Append the manifest
+ iManifestFiles.AppendL( manifestBuf );
+ CleanupStack::Pop( manifestBuf );
+
+ // Append the import
+ iInstallableSisxThemes.AppendL( importName.AllocL() );
+ }
+ }
+ }
+
+ // Now that the manifest list has been parsed, initiate installation of
+ // the new manifest files
+ if( iAutoInstallerState != EAutoInstallerStateInstall )
+ {
+ RunAutoInstaller( EAutoInstallerStateInstall );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::HandleConfigurationImportsL
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::HandleConfigurationImportsL(
+ const TDesC& aFilePrefix )
+ {
+ // Set mask for finding files under imports folder
+ TPtrC filter( KFilterAllPluginImportsV1 );
+ if ( aFilePrefix.CompareF( KPrefixFileApp ) == 0 )
+ {
+ filter.Set( KFilterAllAppImportsV1 );
+ }
+
+ // Get a listing of plugin_*.dat files from the imports folder in C drive
+ CDir* importsDir( NULL );
+ TFindFile fileFinder( iFsSession );
+ fileFinder.FindWildByDir( filter, KImportDirectoryC, importsDir );
+ CleanupStack::PushL( importsDir );
+
+ // pathFileList can be NULL when no path_*.dat files are available in the import folder.
+ // This can mean that currently the last sisx package is under unistallation, and because
+ // of that, we need to check that case with pathFileCount = 0
+ TInt importsCount( 0 );
+ if( importsDir )
+ {
+ importsCount = importsDir->Count();
+ }
+
+ // Find out number of installed themes with the provided file prefix
+ TInt installedCount = 0;
+ const TInt prefixLength = aFilePrefix.Length();
+ for( TInt i=0; i < iInstalledSisxThemes.Count(); i++ )
+ {
+ TPtrC ptr( iInstalledSisxThemes[ i ]->Des() );
+ if ( ptr.Length() > prefixLength )
+ {
+ if ( ptr.Left( prefixLength ).CompareF( aFilePrefix ) == 0 )
+ {
+ installedCount++;
+ }
+ }
+ }
+
+ if( importsCount < installedCount )
+ {
+ // there were less *.dat files than in the last evaluation
+ UninstallImport( importsDir );
+ }
+ else if( importsCount > installedCount && importsDir )
+ {
+ // If a *.dat file was added since the last evaluation
+ InstallImportsL( *importsDir );
+ }
+
+ CleanupStack::PopAndDestroy( importsDir );
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::HandleFileSystemChangeL
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::HandleFileSystemChangeL()
+ {
+ // Install unprocessed plug-in configurations from the import folders,
+ // these might be referenced by one or more application configurations - thus,
+ // this step should be done first!
+ HandleConfigurationImportsL( KPrefixFilePlugin );
+
+ // Install remaining application configurations from the import folders
+ HandleConfigurationImportsL( KPrefixFileApp );
+
+ // File system change can also mean that a theme is being updated
+ HandleThemeUpgradeL();
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::HandleFileSystemChange
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::HandleFileSystemChange()
+ {
+ // Fancy way of checking whether SISX installations are enabled :)
+#ifndef __DISABLE_SISX_INSTALLATION_
+
+ // Register again ...
+ iFileChangeListener->Setup();
+
+ // ... and then handle the change
+ TRAP_IGNORE( HandleFileSystemChangeL() );
+
+#endif // __DISABLE_SISX_INSTALLATION_
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::CheckActiveTheme
+// CheckActiveTheme the specified theme.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+void ChspsThemeServer::CheckActiveThemesL()
+ {
+#ifndef __DISABLE_SISX_INSTALLATION_
+ TInt themeUid;
+ RArray<TUint32> res;
+ CleanupClosePushL( res );
+ TInt errorCode = KErrNone;
+ iCentralRepository->FindL( 0x00000000,0xFFFFFFFF, res );
+ const TInt keyCount = res.Count();
+ for (TInt i = 0; i < keyCount; i++ )
+ {
+ errorCode = iCentralRepository->Get( res[i], themeUid );
+ if ( !errorCode )
+ {
+ HBufC* matchthemeUid = HBufC::NewLC( KMaxFileName );
+ TPtr matchthemeUidPtr = matchthemeUid->Des();
+ matchthemeUidPtr.Append( KPrefixFileApp );
+ matchthemeUidPtr.Append( _L("*_") );
+ matchthemeUidPtr.AppendNumUC( themeUid, EHex );
+ matchthemeUidPtr.Append( _L( "_*" ) );
+
+ HBufC* pathFileName = HBufC::NewL ( KMaxFileName );
+ TPtr pathFileNamePtr = pathFileName->Des();
+ CDir* fileList;
+ TFindFile fileFinder( iFsSession );
+ // Find path info file for matching unique themeuid
+ fileFinder.FindWildByDir( *matchthemeUid, KImportDirectoryC, fileList );
+ if( fileList )
+ {
+ TBool isItOpen = EFalse;
+ pathFileNamePtr.Copy( KImportDirectoryC );
+ pathFileNamePtr.Append( (*fileList)[0].iName );
+ if ( res[i] == KAppId_hspsAS )
+ {
+ errorCode = iFsSession.IsFileOpen( pathFileNamePtr, isItOpen );
+ if ( !isItOpen )
+ {
+ errorCode = iFileAS.Open(iFsSession, pathFileNamePtr, EFileRead );
+ }
+ }
+ else if ( res[i] == KAppId_hspsAI )
+ {
+ errorCode = iFsSession.IsFileOpen( pathFileNamePtr, isItOpen );
+ if ( !isItOpen )
+ {
+ errorCode = iFileAI.Open(iFsSession, pathFileNamePtr, EFileRead );
+ }
+ }
+ else if ( res[i] == KAppId_LE )
+ {
+ errorCode = iFsSession.IsFileOpen( pathFileNamePtr, isItOpen );
+ if ( !isItOpen )
+ {
+ errorCode = iFileLT.Open(iFsSession, pathFileNamePtr, EFileRead );
+ }
+ }
+ }
+ delete fileList;
+ delete pathFileName;
+ CleanupStack::PopAndDestroy( matchthemeUid );
+ }
+ }
+ res.Close();
+ CleanupStack::PopAndDestroy(1, &res);
+#endif //__DISABLE_SISX_INSTALLATION_
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::UnlockSisxImportL()
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::UnlockSisxImportL(
+ const TUint32 aAppUid )
+ {
+__UHEAP_MARK;
+ // Setup a filter for finding an SISX import with the provided application uid
+ HBufC* filterBuf = HBufC::NewLC( KMaxFileName );
+ TPtr filterPtr = filterBuf->Des();
+ filterPtr.Copy( KPrefixFileApp );
+ filterPtr.AppendNumUC( aAppUid, EHex );
+ _LIT(KFilter, "_*_*_1.0.dat");
+ filterPtr.Append( KFilter );
+
+ // Find imports with the generated filter (ROM based imports should not be found)
+ CDir* importsDir( NULL );
+ TFindFile fileFinder( iFsSession );
+ fileFinder.FindWildByDir( filterPtr, KImportDirectoryC, importsDir );
+ if( importsDir )
+ {
+ HBufC* importBuf = HBufC::NewLC ( KMaxFileName );
+ TPtr importPtr = importBuf->Des();
+
+ // CleanupStack is not required since there are no leaving function calls below
+
+ // Loop application specific imports
+ TInt errorCode = KErrNone;
+ TBool isOpen = EFalse;
+ for ( TInt i = 0; i< importsDir->Count(); i++ )
+ {
+ importPtr.Copy( KImportDirectoryC );
+ importPtr.Append( (*importsDir)[i].iName );
+ errorCode = iFsSession.IsFileOpen( importPtr, isOpen );
+ if ( errorCode == KErrNone )
+ {
+ // Only a single file should be open
+ if( isOpen )
+ {
+ // Close application specific file handles
+ if ( aAppUid == KAppId_hspsAS )
+ {
+ iFileAS.Close();
+ }
+ else if ( aAppUid == KAppId_hspsAI )
+ {
+ iFileAI.Close();
+ }
+ else if ( aAppUid == KAppId_LE )
+ {
+ iFileLT.Close();
+ }
+ }
+ }
+ }
+
+ CleanupStack::PopAndDestroy( importBuf );
+ delete importsDir;
+ }
+
+ CleanupStack::PopAndDestroy( filterBuf );
+__UHEAP_MARKEND;
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::LockSisxImportL()
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::LockSisxImportL(
+ const TUint32 aAppUid,
+ const TInt aConfUid )
+ {
+__UHEAP_MARK;
+ // Setup a filter for finding specific application configuration
+ HBufC* filterBuf = HBufC::NewLC( KMaxFileName );
+ TPtr filterPtr = filterBuf->Des();
+ filterPtr.Copy( KPrefixFileApp );
+ filterPtr.Append( _L("*_*_") );
+ filterPtr.AppendNumUC( aConfUid, EHex );
+ filterPtr.Append( _L( "_1.0.dat" ) );
+
+ // Find imports with the generated filter (ROM based imports should not be found)
+ CDir* importsDir( NULL );
+ TFindFile fileFinder( iFsSession );
+ fileFinder.FindWildByDir( filterPtr, KImportDirectoryC, importsDir );
+ if ( importsDir )
+ {
+ CleanupStack::PushL( importsDir );
+
+ // themeuid is unique so count should be 1
+ if ( importsDir->Count() == 1 )
+ {
+ HBufC* importBuf = HBufC::NewLC ( KMaxFileName );
+ TPtr importPtr = importBuf->Des();
+ importPtr.Copy( KImportDirectoryC );
+ importPtr.Append( (*importsDir)[0].iName );
+
+ TBool isOpen = EFalse;
+ TInt errorCode = iFsSession.IsFileOpen( importPtr, isOpen );
+ if ( errorCode == KErrNone && !isOpen )
+ {
+ // Lock the application specific SISX imports
+ if ( aAppUid == KAppId_hspsAS )
+ {
+ errorCode = iFileAS.Open( iFsSession, importPtr, EFileRead );
+ }
+ else if ( aAppUid == KAppId_hspsAI )
+ {
+ errorCode = iFileAI.Open( iFsSession, importPtr, EFileRead );
+ }
+ else if ( aAppUid == KAppId_LE )
+ {
+ errorCode = iFileLT.Open( iFsSession, importPtr, EFileRead );
+ }
+ }
+ CleanupStack::PopAndDestroy( importBuf );
+ }
+
+ CleanupStack::PopAndDestroy( importsDir );
+ }
+
+ CleanupStack::PopAndDestroy( filterBuf );
+__UHEAP_MARKEND;
+ }
+
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::HandleCenRepChangeL()
+// Handles events coming from CentralRepository.
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::HandleCenRepChangeL( const TUint32 aKey )
+ {
+ switch ( aKey )
+ {
+ case KCenrepKeyLang:
+ case KCenrepKeyPostRFS:
+ case KCenrepKeyCheckConf:
+ {
+ // No processing required
+ }
+ break;
+ default:
+ {
+
+ // If SISX installations were enabled
+#ifndef __DISABLE_SISX_INSTALLATION_
+ // Get active application configuration for the provided application uid
+ TInt confUid(0);
+ TInt errorCode = iCentralRepository->Get( aKey, confUid );
+ if ( !errorCode && confUid > 0 )
+ {
+ // Remove file lock from active SISX import
+ UnlockSisxImportL( aKey );
+ // Lock the new SISX import (prevents uninstallation of the SISX
+ // while it's being used as an active application configuration)
+ LockSisxImportL( aKey, confUid );
+ }
+#endif //__DISABLE_SISX_INSTALLATION_
+
+ }
+ }
+
+ // Set up the listener to listen to changes in Central Repository for all settings
+ iCenRepListener->SetupAll();
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::HandleAutoInstallerEvent
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::HandleAutoInstallerEvent( ThspsServiceCompletedMessage aMsg )
+ {
+#ifndef __DISABLE_SISX_INSTALLATION_
+ switch ( aMsg )
+ {
+ case EhspsInstallPhaseSuccess:
+ // Phase was success, installation will continue
+ break;
+ case EhspsInstallThemeSuccess:
+ {
+ // Mark current theme as installed
+ TBool isInstalled = EFalse;
+
+ //check if theme is already listed as installed
+ //there is a possibility that the install is an upgrade and the theme would be alredy listed
+ //in the iInstalledSisxThemes
+ if( iInstalledSisxThemes.Count() > iCurrentManifestFile )
+ {
+ for (TInt i = 0; i < iInstalledSisxThemes.Count(); i++)
+ {
+ if ( *iInstalledSisxThemes[i] == *iInstallableSisxThemes[ iCurrentManifestFile ] )
+ {
+ isInstalled = ETrue;
+ break;
+ }
+ }
+ }
+
+ //if theme is not installed yet than add it to iInstalledSisxThemes
+ if ( !isInstalled )
+ {
+ iInstalledSisxThemes.Append( iInstallableSisxThemes[ iCurrentManifestFile ] );
+ }
+
+ iCurrentManifestFile++;
+
+ // Check if more installable files available
+ delete iAutoInstaller;
+ iAutoInstaller = NULL;
+
+ RunAutoInstaller( EAutoInstallerStateInstall );
+ }
+ break;
+ case EhspsRemoveThemeSuccess:
+ {
+ delete iInstalledSisxThemes[ iThemeIndexToRemove ];
+ iInstalledSisxThemes[ iThemeIndexToRemove ] = NULL;
+ iInstalledSisxThemes.Remove( iThemeIndexToRemove );
+ }
+ /* flow through */
+ case EhspsRemoveThemeFailed:
+ /* flow through */
+ default:
+ StopAutoInstaller();
+ break;
+ }
+#endif //__DISABLE_SISX_INSTALLATION_
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::RunAutoInstaller
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TBool ChspsThemeServer::RunAutoInstaller( TAutoInstallerStates aState )
+ {
+#ifndef __DISABLE_SISX_INSTALLATION_
+ TBool started( EFalse );
+
+ if( !iAutoInstaller )
+ {
+ TRAP_IGNORE( iAutoInstaller = ChspsAutoInstaller::NewL( *this ) );
+#ifdef HSPS_LOG_ACTIVE
+ if ( iAutoInstaller )
+ {
+ iAutoInstaller->SetLogBus( iLogBus );
+ }
+#endif
+ }
+
+ iAutoInstallerState = aState;
+
+ switch( aState )
+ {
+ case EAutoInstallerStateInstall:
+ {
+ if( iCurrentManifestFile < iManifestFiles.Count() )
+ {
+ TInt ret = KErrNone;
+
+ TRAPD( err, ret = iAutoInstaller->InstallThemeL( *iManifestFiles[ iCurrentManifestFile ] ) );
+ if( err == KErrNone && ret == KErrNone )
+ {
+ started = ETrue;
+ }
+ }
+ }
+ break;
+ case EAutoInstallerUninstall:
+ {
+ if( iThemeIndexToRemove != KErrNotFound && iThemeIndexToRemove < iInstalledSisxThemes.Count() )
+ {
+ TRAPD( err, iAutoInstaller->UnInstallThemeL( *iInstalledSisxThemes[ iThemeIndexToRemove ] ) )
+
+ if( !err )
+ {
+ started = ETrue;
+ }
+ else
+ {
+ delete iInstalledSisxThemes[ iThemeIndexToRemove ];
+ iInstalledSisxThemes[ iThemeIndexToRemove ] = NULL;
+ iInstalledSisxThemes.Remove( iThemeIndexToRemove );
+ }
+ }
+ }
+ break;
+ default:
+ {
+ iAutoInstallerState = EAutoInstallerStateIdle;
+ }
+ break;
+ }
+
+ if( !started )
+ {
+ StopAutoInstaller();
+ }
+
+ return started;
+#else
+ return EFalse;
+#endif // __DISABLE_SISX_INSTALLATION_
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::StopAutoInstaller
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::StopAutoInstaller()
+ {
+#ifndef __DISABLE_SISX_INSTALLATION_
+ switch( iAutoInstallerState )
+ {
+ case EAutoInstallerStateInstall:
+ {
+ iCurrentManifestFile = 0;
+ iInstallableSisxThemes.Reset();
+ iManifestFiles.ResetAndDestroy();
+ }
+ break;
+ case EAutoInstallerUninstall:
+ {
+ iThemeIndexToRemove = KErrNotFound;
+ }
+ break;
+ default:
+ break;
+ }
+
+ iAutoInstallerState = EAutoInstallerStateIdle;
+
+ delete iAutoInstaller;
+ iAutoInstaller = NULL;
+#endif // __DISABLE_SISX_INSTALLATION_
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::CheckInstalledPluginUsageL
+// -----------------------------------------------------------------------------
+//
+TInt ChspsThemeServer::CheckInstalledPluginUsageL( const TInt aPluginUid )
+ {
+ TInt sum = 0;
+ if ( iHeaderListCache )
+ {
+ TInt count = iHeaderListCache->Count();
+ if ( iDefinitionRepository->Locked() )
+ {
+ User::Leave( KErrInUse );
+ }
+ iDefinitionRepository->Lock();
+ for ( TInt i = 0; i < count; i++ )
+ {
+ ChspsODT* header = ( *iHeaderListCache )[ i ];
+ if ( header->ConfigurationType() == EhspsAppConfiguration )
+ {
+
+ ChspsODT* odt = ChspsODT::NewL();
+ CleanupStack::PushL( odt );
+ odt->SetRootUid( header->RootUid() );
+ odt->SetThemeUid( header->ThemeUid() );
+ odt->SetConfigurationType( header->ConfigurationType() );
+ odt->SetRootUid( header->RootUid() );
+ odt->SetProviderUid( header->ProviderUid() );
+ odt->SetThemeUid( header->ThemeUid() );
+ odt->SetProviderNameL( header->ProviderName() );
+ odt->SetThemeFullNameL( header->ThemeFullName() );
+ odt->SetThemeShortNameL( header->ThemeShortName() );
+ odt->SetThemeVersionL( header->ThemeVersion() );
+ odt->SetDescriptionL( header->Description() );
+ odt->SetFlags( header->Flags() );
+ odt->SetMultiInstance( header->MultiInstance() );
+ User::LeaveIfError( iDefinitionRepository->GetOdtL( *odt ) );
+ TInt count = 0;
+ hspsServerUtil::PluginInstanceCountL( *odt, aPluginUid, count );
+ sum = sum + count;
+ CleanupStack::PopAndDestroy( odt );
+ }
+ }
+ iDefinitionRepository->Unlock();
+
+ }
+ return sum;
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::PluginInHeaderCache
+// -----------------------------------------------------------------------------
+//
+TBool ChspsThemeServer::PluginInHeaderCache( const TUid aPluginUid )
+ {
+ TBool found = EFalse;
+
+ if ( iHeaderListCache )
+ {
+ const TInt count = iHeaderListCache->Count();
+ for ( TInt i = 0; i < count; i++ )
+ {
+ ChspsODT* header = (*iHeaderListCache)[i];
+ if( header->ThemeUid() == aPluginUid.iUid )
+ {
+ found = ETrue;
+ break;
+ }
+ }
+ }
+
+ return found;
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::UpdateHeaderListCacheL
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::UpdateHeaderListCacheL()
+ {
+ if ( iHeaderListPending )
+ {
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::UpdateHeaderListCacheL(): already updating the cache" ) );
+#endif
+ }
+ else
+ {
+ iHeaderListPending = ETrue;
+
+#ifdef _hsps_PERFORMANCE_TEST_
+ TTime start_time;
+ start_time = ChspsTimeMon::StartTiming(_L("timer started"));
+#endif
+
+ // Get headers from the Plug-in Repository
+ CArrayPtrSeg<ChspsODT>* headerList = new (ELeave)CArrayPtrSeg<ChspsODT>(KHeaderListGranularity);
+ CleanupStack::PushL( headerList );
+
+ // Reset search mask
+ iCacheMask->SetRootUid( 0 );
+ iCacheMask->SetProviderUid( 0 );
+ iCacheMask->SetThemeUid( 0 );
+
+ TInt err = DoUpdateHeaderListCache( *headerList );
+ User::LeaveIfError( err );
+
+ if ( headerList->Count() > 0 )
+ {
+ // Destroys all objects whose pointers form the elements of the array,
+ // before resetting the array.
+ iHeaderListCache->ResetAndDestroy();
+
+ TInt count = headerList->Count() - 1;
+ for (TInt i = count; i >= 0; --i)
+ {
+ // Update the cache array (ownership is transferred)
+ TRAP( err, iHeaderListCache->InsertL(0, headerList->At(i)) );
+
+ // If allocation failed
+ if ( err )
+ {
+ break;
+ }
+
+ // Complete the ownership transfer
+ headerList->Delete(i);
+ }
+ }
+
+ // Destroys all objects whose pointers form the elements of the array,
+ // before resetting the array.
+ headerList->ResetAndDestroy();
+ CleanupStack::PopAndDestroy( headerList );
+
+ // calculating service time
+#ifdef _hsps_PERFORMANCE_TEST_
+ ChspsTimeMon::StopTiming( start_time, _L( "ChspsThemeServer::UpdateHeaderListCache(): - timer stopped" ) );
+#endif
+
+ iHeaderListPending = EFalse;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::UpdateHeaderListCache
+// -----------------------------------------------------------------------------
+//
+TInt ChspsThemeServer::UpdateHeaderListCache(
+ ThspsCacheOperations aOperation,
+ const TInt aRootUid,
+ const TInt aProviderUid,
+ const TInt aConfigurationUid )
+ {
+ TInt err = KErrNone;
+
+ // Input validation
+ if ( aRootUid < 1 || aProviderUid < 1 || aConfigurationUid < 1 )
+ {
+ err = KErrArgument;
+ }
+
+ if ( !err )
+ {
+ if ( aOperation == EhspsCacheAddHeader )
+ {
+ // Add or replace a header in the header list cache
+ TRAP(
+ err,
+ HeaderCacheAddL(
+ aRootUid,
+ aProviderUid,
+ aConfigurationUid )
+ );
+ }
+ else
+ {
+ // Remove a header from the header list cache
+ err = HeaderCacheRemove(
+ aRootUid,
+ aProviderUid,
+ aConfigurationUid
+ );
+ }
+ }
+
+ if ( err )
+ {
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText(
+ _L( "ChspsThemeServer::UpdateHeaderListCache(): - Failed to update %d header in the cache!" ),
+ aConfigurationUid
+ );
+#endif
+ }
+
+ return err;
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::DoUpdateHeaderListCache
+// -----------------------------------------------------------------------------
+//
+TInt ChspsThemeServer::DoUpdateHeaderListCache(
+ CArrayPtrSeg<ChspsODT>& aHeaderList )
+ {
+ // Get headers matching the search mask
+ TRAPD( err, GetHeaderListL( aHeaderList, *iCacheMask ) );
+ if ( err )
+ {
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText(
+ _L( "ChspsThemeServer::DoUpdateHeaderListCache(): - failed %d"),
+ err
+ );
+#endif
+ }
+
+ return err;
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::HeaderCacheAddL
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::HeaderCacheAddL(
+ const TInt aRootUid,
+ const TInt aProviderUid,
+ const TInt aConfigurationUid )
+ {
+ // Setup a search mask
+ iCacheMask->SetRootUid( aRootUid );
+ iCacheMask->SetProviderUid( aProviderUid );
+ iCacheMask->SetThemeUid( aConfigurationUid );
+
+ // Setup a list for headers matching the search mask
+ CArrayPtrSeg<ChspsODT>* newHeadersList = new (ELeave)CArrayPtrSeg<ChspsODT>(KHeaderListGranularity);
+ CleanupStack::PushL( newHeadersList );
+
+ // Find the headers
+ User::LeaveIfError( DoUpdateHeaderListCache( *newHeadersList ) );
+
+ // There should be only one match
+ if ( newHeadersList->Count() != 1 )
+ {
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText(
+ _L( "ChspsThemeServer::HeaderCacheAddL(): - same %S header was found several times!" ),
+ &(newHeadersList->At(0)->ThemeShortName())
+ );
+#endif
+ User::Leave( KErrGeneral );
+ }
+
+ // Set new default position
+ TInt newIndex = 0;
+
+ // Check if old version of the header instance exists in the cache
+ TBool replaced = EFalse;
+ ChspsODT* header = NULL;
+ for( TInt index=0; !replaced && index < iHeaderListCache->Count(); index++ )
+ {
+ header = iHeaderListCache->At( index );
+ if ( header )
+ {
+ if ( header->RootUid() == aRootUid
+ && header->ProviderUid() == aProviderUid
+ && header->ThemeUid() == aConfigurationUid )
+ {
+ // Remove the old header instance
+ iHeaderListCache->Delete( index );
+ delete header;
+ header = NULL;
+ replaced = ETrue;
+ newIndex = index;
+ }
+ }
+ }
+
+ // Append the new version into the specified position (ownership is transferred)
+ iHeaderListCache->InsertL(newIndex, newHeadersList->At(0) );
+
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::HeaderCacheAddL(): - header '%S' was added/updated to cache!" ), &(newHeadersList->At(0)->ThemeShortName()) );
+#endif
+
+ // Complete the ownership transfer
+ newHeadersList->Delete(0);
+
+ // Cleanup
+ newHeadersList->ResetAndDestroy();
+ CleanupStack::PopAndDestroy( newHeadersList );
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::HeaderCacheRemove
+// -----------------------------------------------------------------------------
+//
+TInt ChspsThemeServer::HeaderCacheRemove(
+ const TInt aRootUid,
+ const TInt aProviderUid,
+ const TInt aConfigurationUid )
+ {
+ TInt err = KErrNone;
+
+ // Find the header to be removed from the cache
+ ChspsODT* header = NULL;
+ for( TInt index=0; index < iHeaderListCache->Count(); index++ )
+ {
+ header = iHeaderListCache->At( index );
+ if ( header )
+ {
+ if ( header->RootUid() == aRootUid
+ && header->ProviderUid() == aProviderUid
+ && header->ThemeUid() == aConfigurationUid )
+ {
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::HeaderCacheRemove(): - header '%S' was removed from cache!" ), &(header->ThemeShortName()) );
+#endif
+ iHeaderListCache->Delete( index );
+ delete header;
+ header = NULL;
+ break;
+ }
+ }
+ }
+
+ return err;
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::CompareL
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TBool ChspsThemeServer::ComparePaths(const ChspsODT& aOldHeader, const ChspsODT& aNewHeader)
+ {
+ TBool ret;
+ if (
+ (
+ aOldHeader.RootUid() == aNewHeader.RootUid()
+ )
+ &&
+ (
+ aOldHeader.ProviderUid() == aNewHeader.ProviderUid()
+ )
+ &&
+ (
+ aOldHeader.ThemeUid() == aNewHeader.ThemeUid()
+ )
+ &&
+ (
+ !aOldHeader.ThemeVersion().Compare( aNewHeader.ThemeVersion())
+ )
+ )
+ {
+ ret = ETrue;
+ }
+ else
+ {
+ ret = EFalse;
+ }
+ return ret;
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::GetDeviceLanguage()
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TLanguage ChspsThemeServer::GetDeviceLanguage()
+ {
+ return User::Language();
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::GetHeaderListL
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::GetHeaderListL(CArrayPtrSeg<ChspsODT>& aHeaderList, const ChspsODT& aSearchMask )
+ {
+ CArrayPtrSeg<ChspsODT>* licenceeDefaultList = new (ELeave)CArrayPtrSeg<ChspsODT>( KHeaderListGranularity );
+ CleanupStack::PushL( TCleanupItem( ResetAndDestroyChspsODTArray, licenceeDefaultList ) );
+
+ CArrayPtrSeg<HBufC8>* headerDataList = new (ELeave)CArrayPtrSeg<HBufC8>( KHeaderListGranularity );
+ CleanupStack::PushL( TCleanupItem( ResetAndDestroyHBufC8Array, headerDataList ) );
+ iDefinitionRepository->GetThemeListAsStreamL( *headerDataList, aSearchMask );
+
+ // Convert data streams into header instances and populate the lincencee and header lists
+ for ( TInt i=0; i < headerDataList->Count(); i++ )
+ {
+ HBufC8* headerData = headerDataList->At(i);
+ if ( headerData )
+ {
+ ChspsODT* header = ChspsODT::UnMarshalHeaderLC( *headerData );
+ if ( header->Flags() & EhspsThemeStatusLicenceeDefault )
+ {
+ licenceeDefaultList->AppendL( header );
+ }
+ else
+ {
+ // Get header's file path
+ HBufC* fileBuf = HBufC::NewLC ( KMaxFileName );
+ TPtr filePtr = fileBuf->Des();
+ iDefinitionRepository->GetResourcePathL( *header, EResourceODT, filePtr );
+ aHeaderList.AppendL( header );
+ CleanupStack::PopAndDestroy( fileBuf );
+ }
+ CleanupStack::Pop( header );
+ }
+ }
+
+ // Cleanup the data streams
+ CleanupStack::PopAndDestroy( headerDataList );
+
+
+ // remove duplicate headers from the licencee list
+ if( aHeaderList.Count() )
+ {
+ // go through the theme list again and put back the themes without update
+ const TInt headersCount = aHeaderList.Count();
+ for( TInt i = 0; i < licenceeDefaultList->Count(); i++ )
+ {
+ ChspsODT* licenceeHeader = licenceeDefaultList->At( i );
+
+ TBool found( EFalse );
+ for( TInt j = 0; !found && j < headersCount; j++ )
+ {
+ ChspsODT* header = aHeaderList.At( j );
+
+ // compare two themes to find out are they they the same
+ if( ComparePaths( *header, *licenceeHeader ) )
+ {
+ // there was an update, this theme does not need licencee default
+ licenceeDefaultList->Delete( i );
+ delete licenceeHeader;
+ // next i
+ i--;
+ found = ETrue;
+ }
+ }
+ }
+ }
+
+ // append headers from the licencee list into the headers list
+ for ( TInt i = 0; i < licenceeDefaultList->Count(); i++)
+ {
+ ChspsODT* licenceeHeader = licenceeDefaultList->At(i);
+
+ HBufC8* data = licenceeHeader->MarshalHeaderL();
+ CleanupStack::PushL( data );
+
+ ChspsODT* odt = ChspsODT::UnMarshalHeaderLC( data->Des() );
+ aHeaderList.AppendL( odt );
+ CleanupStack::Pop( odt );
+
+ CleanupStack::PopAndDestroy( data );
+ }
+
+ CleanupStack::PopAndDestroy( licenceeDefaultList );
+
+ // Modify headers flags
+ for ( TInt i = 0; i < aHeaderList.Count(); i++ )
+ {
+ ChspsODT* header = aHeaderList.At(i);
+ TInt appUid = header->RootUid();
+ if ( header->ConfigurationType() == EhspsAppConfiguration )
+ {
+ // Check whether the application has an active configuration
+ TInt confUid = 0;
+ if ( iCentralRepository->Get( appUid, confUid ) == KErrNone && confUid > 0 )
+ {
+ // If active application configuration is the same as the header in question
+ if ( header->ThemeUid() == confUid )
+ {
+ // Update header's flags
+ TUint flags = header->Flags();
+ header->SetFlags( flags | EhspsThemeStatusActive );
+ }
+ }
+ }
+ }
+
+ }
+
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::CustomSecurityCheckL
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+CPolicyServer::TCustomResult ChspsThemeServer::CustomSecurityCheckL(const RMessage2& aMsg,
+ TInt& /*aAction*/, TSecurityInfo& /*aMissing*/ )
+ {
+ CPolicyServer::TCustomResult ret;
+ if ( iSecurityEnforcer->CheckAccessRightsL( aMsg ) )
+ {
+ ret = EPass;
+ }
+ else
+ {
+ ret = EFail;
+ }
+ return ret;
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServerSession::HandleThemeUpgradeL
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::HandleThemeUpgradeL()
+ {
+ CDir* upgradePathFileList( NULL );
+ TFindFile upgradeFileFinder( iFsSession );
+
+ // If a upgrade_path_*.dat file appears in the import directory this means that a theme is being upgraded
+ upgradeFileFinder.FindWildByDir( KUpgradePluginWild ,
+ KImportDirectoryC, upgradePathFileList );
+ if( !upgradePathFileList )
+ {
+ return;
+ }
+ // only one upgrade_path file can be present because it is deleted after upgrade
+ if ( upgradePathFileList->Count() == 1 )
+ {
+ CleanupStack::PushL( upgradePathFileList );
+ TPtrC upgradePathFile( ( *upgradePathFileList )[0].iName );
+
+ //path_*.dat theme file
+ HBufC* fileNamePathOnly = HBufC::NewLC( KMaxFileName );
+ TPtr fileNamePathOnlyPtr( fileNamePathOnly->Des() );
+ TParsePtrC parsePtrTemp( upgradePathFile.Right(
+ upgradePathFile.Length() - KUpgrade().Length() - 1 ) );
+ fileNamePathOnlyPtr.Append( parsePtrTemp.FullName() );
+
+ TBool isInstalled = EFalse;
+ //check if theme is installed
+ for (TInt i = 0; i < iInstalledSisxThemes.Count(); i++)
+ {
+ if ( *iInstalledSisxThemes[i] == *fileNamePathOnly )
+ {
+ isInstalled = ETrue;
+ break;
+ }
+ }
+
+ if ( !isInstalled )
+ {
+ // base theme package is not an installed theme
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "hspsThemeServer: ChspsThemeServer::HandleThemeUpgradeL(): Base theme package not installed" ) );
+#endif
+ }
+ else
+ {
+ //upgrade_path_*.dat file path portion
+ TParsePtrC parsePtr( upgradePathFile.Right(
+ upgradePathFile.Length() - KUpgradePlugin().Length() - 1 ) );
+ TPtrC fileNameUpgradePath( parsePtr.Name() );
+
+ //path to manifest
+ HBufC* manifestFile = HBufC::NewLC( KMaxFileName );
+ TPtr manifestFilePtr( manifestFile->Des() );
+ manifestFilePtr.Append( KImportDirectoryC );
+ manifestFilePtr.Append( fileNameUpgradePath );
+
+ TInt pos( manifestFilePtr.Locate( TChar( '_' ) ) );
+ while( pos != KErrNotFound )
+ {
+ manifestFilePtr.Replace( pos, 1, KDoubleBackSlash );
+ pos = manifestFilePtr.Locate( TChar( '_' ) );
+ }
+
+ manifestFilePtr.Append( KDoubleBackSlash );
+ manifestFilePtr.Append( KManifestFile );
+
+ //store manifest file for autoinstaller
+ iManifestFiles.AppendL( manifestFile );
+
+ //Store current path_*.dat file
+ iInstallableSisxThemes.AppendL( ( *fileNamePathOnly ).AllocL() );
+ iCurrentManifestFile = 0;
+
+ if( !RunAutoInstaller( EAutoInstallerStateInstall ) )
+ {
+ // All installation files are not present
+ // here should be some kind of error handling
+ }
+
+ CleanupStack::Pop( manifestFile ); //manifestFile
+ }
+
+ HBufC * upgradePathFileToDelete = HBufC::NewLC( KMaxFileName );
+ TPtr upgradePathFileToDeletePtr( upgradePathFileToDelete->Des() );
+ upgradePathFileToDeletePtr.Append( KImportDirectoryC );
+ upgradePathFileToDeletePtr.Append( upgradePathFile );
+
+ //delete the upgrade_path_*.dat auxiliary file
+ TInt err = iFsSession.Delete( *upgradePathFileToDelete );
+ if ( err != KErrNone )
+ {
+#ifdef HSPS_LOG_ACTIVE
+ //file not deleted error handling
+ iLogBus->LogText( _L( "hspsThemeServer: ChspsThemeServer::HandleThemeUpgradeL(): %d ,upgrade_path_*.dat file not deleted" ), err );
+#endif
+ }
+
+ CleanupStack::PopAndDestroy( upgradePathFileToDelete );
+ CleanupStack::PopAndDestroy( fileNamePathOnly );
+ CleanupStack::PopAndDestroy( upgradePathFileList );
+ }
+ else
+ {
+#ifdef HSPS_LOG_ACTIVE
+ //more than one upgrade_path is present. in import directory error handling
+ iLogBus->LogText( _L( "hspsThemeServer: ChspsThemeServer::HandleThemeUpgradeL(): more than one upgrade_path_*.dat file" ) );
+#endif
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// Checks whether the device language has been changed and updates
+// configurations accordingly
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::HandleLanguageChangeL()
+ {
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::HandleLanguageChangeL()") );
+#endif
+
+ // The key should already exist
+ const TUint32 fullMask = 0xFFFFFFFF;
+ RArray<TUint32> res;
+ CleanupClosePushL( res );
+
+ iCentralRepository->FindL( KCenrepKeyLang, fullMask, res );
+ if ( res.Count() == 0 )
+ {
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText(
+ _L( "ChspsThemeServer::HandleLanguageChangeL(): - Couldn't find %d key from the HSPS cenrep!" ),
+ KCenrepKeyLang );
+#endif
+
+ User::Leave( KErrNotFound );
+ }
+
+ // Check the cenrep key's value
+ TInt prevLanguage = ELangNone;
+ iCentralRepository->Get( KCenrepKeyLang, prevLanguage );
+
+ // If the language has been changed
+ if( iDeviceLanguage != prevLanguage )
+ {
+ // Update all the ODTs so that the localized configurations can be fetched
+ LocalizeConfigurationsL();
+
+ UpdateHeaderListCacheL();
+
+ // Finally, update the cenrep with the new language
+ TInt errorCode = iCentralRepository->Set( KCenrepKeyLang, iDeviceLanguage );
+ if ( errorCode )
+ {
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::HandleLanguageChangeL(): - Failed to update the cenrep!" ) );
+#endif
+
+ User::Leave( KErrWrite );
+ }
+ else
+ {
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::HandleLanguageChangeL(): - themes were localized successfully" ) );
+#endif
+ }
+ }
+
+ res.Close();
+ CleanupStack::PopAndDestroy(1, &res);
+ }
+
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::SetHeadersLanguages()
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::LocalizeConfigurationsL()
+ {
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::LocalizeConfigurationsL()" ) );
+#endif
+
+ // Check header count
+ TInt headerCount = HeaderListCache().Count();
+ if( headerCount )
+ {
+ _LIT8(KhspsDefinitionEngine, "hspsdefinitionengine");
+ ChspsDefinitionEngineInterface* defEngine = ChspsDefinitionEngineInterface::NewL(KhspsDefinitionEngine);
+ CleanupStack::PushL( defEngine );
+
+ // Loop found headers
+ ChspsODT* header = NULL;
+ const TInt KInterfaceUid = 0;
+ for( TInt headerIndex=0; headerIndex < headerCount; headerIndex++ )
+ {
+ // Get pointer to the header (contains minimal information from an ODT)
+ header = iHeaderListCache->At( headerIndex );
+
+ // Get the ODT based on header UIDs
+ ChspsODT* odt = ChspsODT::NewL();
+ CleanupStack::PushL( odt );
+ GetConfigurationL(
+ KInterfaceUid,
+ header->ThemeUid(),
+ *odt );
+ if ( !odt || !odt->ThemeUid() )
+ {
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::LocalizeConfigurationsL(): - Failed to retrieve header with an configuration uid %d" ),
+ header->ThemeUid() );
+#endif
+
+ User::Leave( KErrNotFound );
+ }
+
+ // Try to localize the ODT according to the new device language
+ TBool localized = LocalizeL(
+ *defEngine,
+ *odt );
+ if ( localized )
+ {
+ // Set header's name from the ODT
+ header->SetThemeFullNameL( odt->ThemeFullName() );
+ header->SetDescriptionL( odt->Description() );
+ }
+
+ CleanupStack::PopAndDestroy( odt );
+ } // for loop
+
+ CleanupStack::PopAndDestroy( defEngine );
+
+ } // count
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::ResetResourcesL()
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::ResetResourcesL(
+ ChspsODT& aAppODT )
+ {
+ // If active configuration
+ TInt confUid = -1;
+ iCentralRepository->Get( aAppODT.RootUid(), confUid );
+ if( confUid == aAppODT.ThemeUid() )
+ {
+ if( !iFileMan )
+ {
+ iFileMan= CFileMan::NewL( iFsSession );
+ }
+
+ // Find unique plug-in UIDs from the app configuration
+ RArray<TInt> uidArray;
+ CleanupClosePushL( uidArray );
+ hspsServerUtil::FindUniquePluginsL( aAppODT, uidArray );
+
+ // Remove old copies from the client path, localized copies will be
+ // restored when the app configuration is fetched again
+ for( TInt i=0; i < uidArray.Count(); i++ )
+ {
+ ChspsODT* pluginODT = ChspsODT::NewL();
+ CleanupStack::PushL( pluginODT );
+
+ GetConfigurationL(
+ 0,
+ uidArray[i],
+ *pluginODT );
+
+ if( pluginODT->ThemeUid() )
+ {
+ hspsServerUtil::RemoveResourceFilesL(
+ *iFileMan,
+ iFsSession,
+ aAppODT.RootUid(),
+ *pluginODT );
+ }
+
+ CleanupStack::PopAndDestroy();
+ }
+
+ uidArray.Reset();
+ CleanupStack::PopAndDestroy( &uidArray );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::LocalizeL()
+// -----------------------------------------------------------------------------
+//
+TBool ChspsThemeServer::LocalizeL(
+ ChspsDefinitionEngineInterface& aEngine,
+ ChspsODT& aOdt )
+ {
+ TBool localized = ETrue;
+ iFsSession.SetSessionToPrivate( EDriveC );
+
+ TLanguage requestedLanguage = DeviceLanguage();
+ if ( requestedLanguage == ELangNone )
+ {
+ requestedLanguage = ELangTest;
+ }
+
+ if ( aOdt.OdtLanguage() != requestedLanguage )
+ {
+ localized = EFalse;
+ TBool domChanged = EFalse;
+
+ // Localize XML configuration with the requested language
+ if ( aOdt.ConfigurationType() == EhspsAppConfiguration )
+ {
+ // Apply plugin and application specific DTD files
+ domChanged = LocalizeApplicationConfigurationL(
+ aEngine,
+ aOdt,
+ requestedLanguage );
+
+ ResetResourcesL( aOdt );
+ }
+ else
+ {
+ // Apply plugin specific DTD files only
+ domChanged = LocalizePluginConfigurationL(
+ aEngine,
+ aOdt,
+ requestedLanguage,
+ 0 );
+ }
+
+ if ( domChanged )
+ {
+ // Update ODT with the new localized name from the XML configuration
+ TPtrC8 name( hspsServerUtil::FindConfigurationAttrL( aOdt, KConfigurationAttrName ) );
+ if ( name.Length() )
+ {
+ HBufC* buf = HBufC::NewLC( name.Length() );
+ buf->Des().Copy( name );
+ aOdt.SetThemeFullNameL( buf->Des() );
+ CleanupStack::PopAndDestroy( buf );
+
+ // The ODT instance has now been localized - either with the requested language or a test language
+ aOdt.SetOdtLanguage( requestedLanguage );
+ }
+
+ // Update ODT with the new localized description from the XML configuration
+ TPtrC8 desc( hspsServerUtil::FindConfigurationAttrL( aOdt, KConfigurationAttrDesc ) );
+ if ( desc.Length() )
+ {
+ HBufC* buf = HBufC::NewLC( desc.Length() );
+ buf->Des().Copy( desc );
+ aOdt.SetDescriptionL( buf->Des() );
+ CleanupStack::PopAndDestroy( buf );
+ }
+
+ // Save the changes
+ iDefinitionRepository->SetOdtL( aOdt );
+ localized = ETrue;
+ }
+
+ if ( !localized )
+ {
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText(
+ _L( "ChspsThemeServer::LocalizeL(): - failed to localize header %S!" ),
+ &aOdt.ThemeShortName()
+ );
+#endif
+ }
+
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::LocalizeL() - DOM dump after localization:" ) );
+ // Print DOM debug
+ ChspsOdtDump::Dump( aOdt, *iLogBus );
+#endif
+ }
+
+ return localized;
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::LocalizeApplicationConfigurationL()
+// -----------------------------------------------------------------------------
+//
+TBool ChspsThemeServer::LocalizeApplicationConfigurationL(
+ ChspsDefinitionEngineInterface& aEngine,
+ ChspsODT& aOdt,
+ const TLanguage aRequestedLanguage )
+ {
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText(
+ _L( "ChspsThemeServer::LocalizeApplicationConfigurationL(): - Localizing %S application configuration..." ),
+ &aOdt.ThemeShortName()
+ );
+#endif
+
+ // Localize the application configuration itself
+ TInt resourceFilter = aOdt.ThemeUid();
+ TBool domLocalized = LocalizePluginConfigurationL(
+ aEngine,
+ aOdt,
+ aRequestedLanguage,
+ resourceFilter );
+
+ // Next, localize all plugins instances in the DOM
+ if ( domLocalized )
+ {
+ // Find all unique plugin uids that are used in the application configuration
+ RArray<TInt> pluginArray;
+ CleanupClosePushL( pluginArray );
+ hspsServerUtil::FindUniquePluginsL( aOdt, pluginArray );
+
+ // Loop the plugins
+ const TInt pluginsCount = pluginArray.Count();
+ for( TInt pluginIndex=0; domLocalized && pluginIndex < pluginsCount; pluginIndex++ )
+ {
+ // Apply plugin specific DTD files only
+ TBool pluginLocalized = LocalizePluginConfigurationL(
+ aEngine,
+ aOdt,
+ aRequestedLanguage,
+ pluginArray[pluginIndex] );
+ }
+
+ pluginArray.Reset();
+ CleanupStack::PopAndDestroy( &pluginArray );
+ }
+
+ return domLocalized;
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::LocalizePluginConfigurationL()
+// -----------------------------------------------------------------------------
+//
+TBool ChspsThemeServer::LocalizePluginConfigurationL(
+ ChspsDefinitionEngineInterface& aEngine,
+ ChspsODT& aOdt,
+ const TLanguage aRequestedLanguage,
+ TInt aPluginUid )
+ {
+ // If the plugin has already been localized as requested
+ if ( aOdt.OdtLanguage() == aRequestedLanguage )
+ {
+ return ETrue;
+ }
+
+ TBool domLocalized = EFalse;
+ const TInt resourceCount = aOdt.ResourceCount();
+
+ // Localize XML document
+ TFileName pluginFolder;
+ for( TInt resourceIndex=0; !domLocalized && resourceIndex < resourceCount; resourceIndex++ )
+ {
+ ChspsResource& r = aOdt.ResourceL( resourceIndex );
+ if ( r.ResourceType() == EResourceDTD )
+ {
+ TBool isPluginSpecific = ETrue;
+
+ // If plugin uid restriction was set (localizing an application configuration)
+ if ( aPluginUid > 0 )
+ {
+ // Check whether the resource belongs to the plugin
+ pluginFolder.Format( _L("\\%d\\"), aPluginUid );
+ isPluginSpecific = ( r.FileName().Find(pluginFolder) > 0 );
+ }
+ if ( isPluginSpecific && r.Language() == aRequestedLanguage )
+ {
+ // Parses the given DTD file and replaces all entity referencies in the DOM tree
+ aEngine.ApplyLanguageL(
+ iFsSession,
+ r.FileName(),
+ aOdt );
+ domLocalized = ETrue;
+#ifdef HSPS_LOG_ACTIVE
+ if ( aPluginUid > 0 )
+ {
+ iLogBus->LogText(
+ _L( "ChspsThemeServer::LocalizePluginConfigurationL(): - %S/%X instances localized to %d language!" ),
+ &aOdt.ThemeShortName(),
+ aPluginUid,
+ aRequestedLanguage );
+ }
+ else
+ {
+ iLogBus->LogText(
+ _L( "ChspsThemeServer::LocalizePluginConfigurationL(): - %S localized to %d language!" ),
+ &aOdt.ThemeShortName(),
+ aRequestedLanguage );
+ }
+#endif
+ }
+ }
+ }
+
+ // If the requested locale couldn't be found
+ if ( !domLocalized )
+ {
+ // Localize XML document with the test locale (mandatory language, used by HSPS developers)
+ for( TInt resourceIndex=0; !domLocalized && resourceIndex < resourceCount; resourceIndex++ )
+ {
+ ChspsResource& r = aOdt.ResourceL( resourceIndex );
+ if ( r.ResourceType() == EResourceDTD )
+ {
+ TBool isPluginSpecific = ETrue;
+
+ // If plugin uid restriction was set (localizing an application configuration)
+ if ( aPluginUid > 0 )
+ {
+ // Check whether the resource belongs to the plugin
+ pluginFolder.Format( _L("\\%d\\"), aPluginUid );
+ isPluginSpecific = ( r.FileName().Find(pluginFolder) > 0 );
+ }
+ if ( isPluginSpecific && r.Language() == ELangTest )
+ {
+ // Parses the given DTD file and replaces all entity referencies in the DOM tree
+ aEngine.ApplyLanguageL(
+ iFsSession,
+ r.FileName(),
+ aOdt );
+ domLocalized = ETrue;
+#ifdef HSPS_LOG_ACTIVE
+ if ( aPluginUid > 0 )
+ {
+ iLogBus->LogText(
+ _L( "ChspsThemeServer::LocalizePluginConfigurationL(): - %S/%X instances localized to %d language!" ),
+ &aOdt.ThemeShortName(),
+ aPluginUid,
+ ELangTest );
+ }
+ else
+ {
+ iLogBus->LogText(
+ _L( "ChspsThemeServer::LocalizePluginConfigurationL(): - %S localized to %d language!" ),
+ &aOdt.ThemeShortName(),
+ ELangTest );
+ }
+#endif
+ }
+ }
+ }
+ }
+
+ return domLocalized;
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::GetConfigurationL()
+// -----------------------------------------------------------------------------
+//
+TInt ChspsThemeServer::GetConfigurationL(
+ const TInt aInterfaceUid,
+ const TInt aConfigurationUid,
+ ChspsODT& aRetrievedODT )
+ {
+ // Input validation
+ if ( aInterfaceUid < 0 || aConfigurationUid < 1)
+ {
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::GetConfigurationL(): - Invalid arguments" ) );
+#endif
+
+ return KErrArgument;
+ }
+
+ TInt headerCount = HeaderListCache().Count();
+ if ( headerCount < 1 )
+ {
+ UpdateHeaderListCacheL();
+ headerCount = HeaderListCache().Count();
+ if ( headerCount < 1 )
+ {
+ // configurations were not found or repository is locked
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::GetConfigurationL(): - Cache is empty" ) );
+#endif
+ return KErrAbort;
+ }
+ }
+
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::GetConfigurationL(): - header count in cache: %d" ), iHeaderListCache->Count() );
+#endif
+
+ // Loop headers in the cache
+ TBool found = EFalse;
+ ChspsODT* h = NULL;
+ for ( TInt i=0; !found && i<iHeaderListCache->Count(); i++ )
+ {
+ h = iHeaderListCache->At(i);
+ TBool rootUidMatched = ETrue;
+ TBool themeUidMatched = ETrue;
+ if ( aInterfaceUid )
+ {
+ rootUidMatched = ( h->RootUid() == aInterfaceUid );
+ }
+ themeUidMatched = ( h->ThemeUid() == aConfigurationUid );
+
+ found = ( rootUidMatched && themeUidMatched );
+//#ifdef HSPS_LOG_ACTIVE
+// iLogBus->LogText( _L( "ChspsThemeServer::GetConfigurationL(): - header '%S' matched: %d" ), &(h->ThemeShortName()), found );
+//#endif
+ }
+ if ( !found )
+ {
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::GetConfigurationL(): - theme %D was not found!" ), aConfigurationUid );
+#endif
+ return KErrNotFound;
+ }
+
+ // Copy properties which are needed by the definition repository to form up ODT paths
+ aRetrievedODT.SetRootUid( h->RootUid() );
+ aRetrievedODT.SetThemeUid( h->ThemeUid() );
+ aRetrievedODT.SetConfigurationType(h->ConfigurationType());
+ aRetrievedODT.SetRootUid(h->RootUid());
+ aRetrievedODT.SetProviderUid(h->ProviderUid());
+ aRetrievedODT.SetThemeUid(h->ThemeUid());
+ aRetrievedODT.SetProviderNameL(h->ProviderName());
+ aRetrievedODT.SetThemeFullNameL(h->ThemeFullName());
+ aRetrievedODT.SetThemeShortNameL(h->ThemeShortName());
+ aRetrievedODT.SetThemeVersionL(h->ThemeVersion());
+ aRetrievedODT.SetFlags(h->Flags());
+ aRetrievedODT.SetMultiInstance( h->MultiInstance() );
+
+ // Get a complete ODT instance from the definition repository
+ if ( iDefinitionRepository->GetOdtL( aRetrievedODT ) )
+ {
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::GetConfigurationL(): - theme cannot be accessed." ) );
+#endif
+ return KErrAccessDenied;
+ }
+
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::InstallUDAWidgetsL()
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::InstallUDAWidgetsL( const TDesC& aImportDirectory )
+ {
+ //Get list of uda dir's
+ TPtrC filter( KFilterAllPluginImportsV1 );
+ CDir* importDir( NULL );
+ TFindFile fileFinder( iFsSession );
+ fileFinder.FindWildByDir( filter, aImportDirectory, importDir );
+ CleanupStack::PushL( importDir );
+
+ if ( importDir && importDir->Count() > 0 )
+ {
+ CHSPSInstaller* installer = CHSPSInstaller::NewL( *this );
+ CleanupStack::PushL( installer );
+
+ for ( TInt i = 0; i < importDir->Count(); i++ )
+ {
+ TPtrC udaName( (*importDir)[i].iName );
+ // Get manifest path
+ HBufC* manifestBuf = GetManifestFromImportLC(
+ udaName,
+ aImportDirectory );
+
+ //install
+ TRAPD( err, installer->InstallConfigurationL( *manifestBuf ) );
+ if ( err != KErrNone )
+ {
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::InstallUDAWidgetsL(): - Installation failed" ) );
+#endif
+ }
+ CleanupStack::PopAndDestroy( manifestBuf );
+ }
+ CleanupStack::PopAndDestroy( installer );
+ }
+ CleanupStack::PopAndDestroy( importDir );
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::HandleRomInstallationsL()
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::HandleRomInstallationsL()
+ {
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::HandleRomInstallationsL()" ) );
+#endif
+
+ const TInt key = KCenrepKeyPostRFS;
+ const TUint32 fullMask = 0xFFFFFFFF;
+ RArray<TUint32> res;
+ CleanupClosePushL( res );
+ iCentralRepository->FindL( key, fullMask, res );
+ if ( res.Count() == 0 )
+ {
+ // The key should already exist!
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::HandleRomInstallationsL(): - Couldn't find %d key from the HSPS cenrep!" ), key );
+#endif
+
+ User::Leave( KErrNotFound );
+ }
+
+ // Check the key's value
+ // lets use KSysUtilVersionTextLength instead of KSysVersionInfoRevisionLength if we
+ // have to use SysUtil::GetSWVersion because KSysUtilVersionTextLength is bigger.
+ TBuf<KSysUtilVersionTextLength> fwVersion;
+ TInt errorCode = iCentralRepository->Get( key, fwVersion );
+ if( ( errorCode == KErrNone ) &&
+ ( fwVersion.Length() == 0 ) )
+ {
+ // Install widgets from install and import directories (eMMC, UDA ROM)
+ InstallWidgetsL( ETrue );
+
+ // Post RFS installations have been done, prevent re-installations at next startup
+ // by reading firmware version and saving it to cenrep.
+ GetFWVersion( fwVersion );
+
+ errorCode = iCentralRepository->Set( key, fwVersion );
+ if ( errorCode )
+ {
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::HandleRomInstallationsL(): - Failed to update the cenrep!" ) );
+#endif
+
+ User::Leave( KErrWrite );
+ }
+ else
+ {
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::HandleRomInstallationsL(): - ROM configurations were installed successfully." ) );
+#endif
+ }
+ }
+ else
+ {
+ // We have to check whether phone software has been updated for example by FOTA.
+ // If the firmware version is different we need to run backup and restore to
+ // check whether there are any new widgets introduced and check can we use
+ // still same application configure. If firmware is same nothing needs to be done.
+ TBuf<KSysUtilVersionTextLength> currentFWVersion;
+ GetFWVersion( currentFWVersion );
+ if ( fwVersion != currentFWVersion )
+ {
+ // Phone software has been updated.
+ CreateBackupDataL();
+ InstallWidgetsL( EFalse );
+ // Restore the personalization
+ RestoreApplicationConfigurationsL();
+ // Save new firmware version to cenrep
+ if ( errorCode == KErrNone )
+ {
+ errorCode = iCentralRepository->Set( key, currentFWVersion );
+ }
+ else if ( errorCode == KErrArgument )
+ {
+ // We came here because older version of HSPS cenrep value
+ // of key was integer and now it is string.
+ // Delete key and create new with different type
+ iCentralRepository->Delete( key );
+ errorCode = iCentralRepository->Create( key, currentFWVersion );
+ }
+
+ if ( errorCode )
+ {
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::HandleRomInstallationsL(): - Failed to update the cenrep!" ) );
+#endif
+
+ User::Leave( KErrWrite );
+ }
+ else
+ {
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::HandleRomInstallationsL(): - ROM configurations were installed successfully." ) );
+#endif
+ }
+ }
+ }
+
+#if defined(WINSCW) || defined(__WINS__)
+ // Activate client specific root configurations from active display resolution
+ ActivateRootConfigurationsL();
+#endif // defined(WINSCW)
+
+ res.Close();
+ CleanupStack::PopAndDestroy(1, &res);
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::InstallWidgetsL()
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::InstallWidgetsL(
+ const TBool aInstallUdaEmmc )
+ {
+ __ASSERT_DEBUG( !iRomInstaller, User::Leave( KErrGeneral) );
+ iRomInstaller = ChspsRomInstaller::NewL(
+ *this,
+ iFsSession,
+ aInstallUdaEmmc );
+#ifdef HSPS_LOG_ACTIVE
+ iRomInstaller->SetLogBus( iLogBus );
+#endif
+
+ iRomInstaller->InstallL();
+
+ delete iRomInstaller;
+ iRomInstaller = 0;
+
+ // Force updating of the header cache
+ TRAP_IGNORE( UpdateHeaderListCacheL() );
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::GetConfigurationHeader()
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::GetConfigurationHeader(
+ ChspsODT& aSearchMask,
+ ChspsODT*& aConfHeader,
+ TInt& aPos )
+ {
+ ChspsODT* header( NULL );
+ aConfHeader = NULL;
+ for ( TInt i = aPos; i < iHeaderListCache->Count() && aConfHeader == NULL; i++ )
+ {
+ TBool rootUidMatch( ETrue );
+ TBool themeUidMatch( ETrue );
+ TBool flagsMatch( ETrue );
+ TBool typeMatch( ETrue );
+ TBool familyMatch( ETrue );
+
+ header = iHeaderListCache->At(i);
+
+ if ( aSearchMask.RootUid() &&
+ aSearchMask.RootUid() != header->RootUid() )
+ {
+ // Root UID defined in search criteria and Root UID does not match
+ rootUidMatch = EFalse;
+ }
+ // else Root UID check ignored
+ if ( aSearchMask.ThemeUid() &&
+ aSearchMask.ThemeUid() != header->ThemeUid() )
+ {
+ // Theme UID defined in search criteria and Theme UID does not match
+ themeUidMatch = EFalse;
+ }
+ // else Theme UID check ignored
+ if ( aSearchMask.Flags() &&
+ !( aSearchMask.Flags() & header->Flags() ) )
+ {
+ // Header flags defined in search criteria and Header flags does not match
+ flagsMatch = EFalse;
+ }
+ // else header flags check ignored
+ if ( aSearchMask.ConfigurationType() &&
+ aSearchMask.ConfigurationType() != header->ConfigurationType() )
+ {
+ typeMatch = EFalse;
+ }
+ if ( aSearchMask.Family() &&
+ !( aSearchMask.Family() & header->Family() ) )
+ {
+ // Family does not match
+ familyMatch = EFalse;
+ }
+ // else configuration type ignored
+ if ( rootUidMatch && themeUidMatch && flagsMatch && typeMatch && familyMatch )
+ {
+ aConfHeader = header;
+ aPos = i;
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::ReinstallConfL()
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::ReinstallConfL(
+ TInt aAppUid,
+ TInt aConfUid )
+ {
+
+ RFs fileserver;
+ CleanupClosePushL( fileserver );
+ User::LeaveIfError( fileserver.Connect() );
+
+ ChspsRomInstaller* installer = ChspsRomInstaller::NewL( *this, fileserver );
+ CleanupStack::PushL( installer );
+
+ installer->ReinstallThemeL( aAppUid, aConfUid );
+
+ CleanupStack::PopAndDestroy( installer );
+ CleanupStack::PopAndDestroy( &fileserver );
+
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::HandleBREventL()
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::HandleBREventL(
+ TInt aEvent )
+ {
+
+ switch ( iBRState )
+ {
+ case EhspsBRRestore:
+ {
+ HandleBRRestoreStateL( aEvent );
+ }
+ break;
+ case EhspsBRBackup:
+ {
+ HandleBRBackupStateL( aEvent );
+ }
+ break;
+ default: // EhspsBRNormal
+ {
+ HandleBRNormalStateL( aEvent );
+ }
+ break;
+ }
+
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::HandleBRNormalStateL()
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::HandleBRNormalStateL(
+ TInt aEvent )
+ {
+ if ( aEvent & conn::EBURBackupFull ||
+ aEvent & conn::EBURBackupPartial )
+ {
+ CreateBRHandlerL( aEvent );
+ if ( iBRHandler && iActiveBackupClient )
+ {
+ iBRState = EhspsBRBackup;
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::HandleBRNormalStateL(): - Backup starts" ) );
+#endif
+ }
+ }
+
+ if ( aEvent & conn::EBURRestoreFull ||
+ aEvent & conn::EBURRestorePartial )
+ {
+ CreateBRHandlerL( aEvent );
+ if ( iBRHandler && iActiveBackupClient )
+ {
+ iBRState = EhspsBRRestore;
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::HandleBRNormalStateL(): - Restore starts" ) );
+#endif
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::HandleBRBackupStateL()
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::HandleBRBackupStateL(
+ TInt aEvent )
+ {
+ if ( aEvent & conn::EBURNormal )
+ {
+ DeleteBRHandler();
+ iBRState = EhspsBRNormal;
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::HandleBRBackupStateL(): - Backup completed" ) );
+#endif
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::HandleBRRestoreState()
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::HandleBRRestoreStateL(
+ TInt aEvent )
+ {
+ if ( aEvent & conn::EBURNormal )
+ {
+ // Disable auto installations
+ DisableAutoInstallation();
+ // Restore imported configurations from backup/import folder
+ RestoreImportedConfigurationsL();
+ // Update cache
+ UpdateHeaderListCacheL();
+ // Restore application configurations from backup/themes folder
+ RestoreApplicationConfigurationsL();
+ // Restore completed
+ DeleteBRHandler();
+ iBRState = EhspsBRNormal;
+ EnableAutoInstallationL();
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::HandleBRRestoreStateL(): - Restore completed" ) );
+#endif
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::CreateBRHandlerL()
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::CreateBRHandlerL(
+ TInt aEvent )
+ {
+ if ( !iBRHandler )
+ {
+ iBRHandler = CHSPSBRHandler::NewL( *this );
+ }
+ if ( !iActiveBackupClient )
+ {
+ iActiveBackupClient = conn::CActiveBackupClient::NewL( iBRHandler );
+ }
+ if ( aEvent & conn::EBURBackupPartial ||
+ aEvent & conn::EBURRestorePartial )
+ {
+ if( !iActiveBackupClient->DoesPartialBURAffectMeL() )
+ {
+ DeleteBRHandler();
+ }
+ }
+ if ( iBRHandler && iActiveBackupClient )
+ {
+ iActiveBackupClient->ConfirmReadyForBURL( KErrNone );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::DeleteBRHandler()
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::DeleteBRHandler()
+ {
+ delete iActiveBackupClient;
+ iActiveBackupClient = NULL;
+ delete iBRHandler;
+ iBRHandler = NULL;
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::CreateBackupDataL()
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::CreateBackupDataL()
+ {
+
+ // Clear previous backup data
+ iDefinitionRepository->ClearBackupsL();
+
+ // Get first application configuration header
+ ChspsODT* searchMask = ChspsODT::NewL();
+ CleanupStack::PushL( searchMask );
+ searchMask->SetConfigurationType( EhspsAppConfiguration );
+ ChspsODT* confHeader( NULL );
+ TInt pos( 0 );
+ GetConfigurationHeader( *searchMask, confHeader, pos );
+
+ while ( confHeader != NULL )
+ {
+ // Backup application configuration
+ iDefinitionRepository->BackupConfigurationL( *confHeader );
+ // Get next application configuration header
+ pos++;
+ GetConfigurationHeader( *searchMask, confHeader, pos );
+ }
+
+ CleanupStack::PopAndDestroy( searchMask );
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::EnableAutoInstallationL()
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::EnableAutoInstallationL()
+ {
+
+ // Reset installation arrays
+ iInstallableSisxThemes.Reset();
+ iInstalledSisxThemes.ResetAndDestroy();
+ iManifestFiles.ResetAndDestroy();
+
+ // Get installed configurations from the import folders
+ CDir* fileList( NULL );
+ TFindFile fileFinder( iFsSession );
+ fileFinder.FindWildByDir(
+ KFilterAllImportsV1,
+ KImportDirectoryC,
+ fileList );
+ CleanupStack::PushL( fileList );
+ if( fileList )
+ {
+ const TInt installedCount = fileList->Count();
+ for( TInt i = 0; i < installedCount ; i++ )
+ {
+ const TEntry& entry = (*fileList)[i];
+ iInstalledSisxThemes.AppendL( entry.iName.AllocL() );
+ }
+ }
+ CleanupStack::PopAndDestroy( fileList );
+
+ // Create file change listener to observe changes in import folder
+ delete iFileChangeListener;
+ iFileChangeListener = NULL;
+ iFileChangeListener = ChspsFileChangeListener::NewL(
+ iFsSession,
+ *this,
+ ENotifyAll,
+ KImportDirectoryC,
+ TImportDirListener );
+#ifdef HSPS_LOG_ACTIVE
+ iFileChangeListener->SetLogBus( iLogBus );
+#endif
+ iFileChangeListener->Setup();
+
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::DisableAutoInstallation()
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::DisableAutoInstallation()
+ {
+ // Reset installation arrays
+ iInstallableSisxThemes.Reset();
+ iInstalledSisxThemes.ResetAndDestroy();
+ iManifestFiles.ResetAndDestroy();
+
+ // Delete import folder observer
+ delete iFileChangeListener;
+ iFileChangeListener = NULL;
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::RestoreImportedConfigurationsL()
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::RestoreImportedConfigurationsL()
+ {
+ // Check that import folder exists and can be opened
+ if ( BaflUtils::CheckFolder( iFsSession, KImportDirectoryC ) == KErrNone )
+ {
+ // Get list of restored configuration manifest.dat files included in
+ // import directory
+ RArray <TFileName> files;
+ CleanupClosePushL( files );
+ hspsServerUtil::FindFilesL(
+ KImportDirectoryC,
+ KManifestFile,
+ files );
+
+ // Install found configurations
+ TInt err( KErrNone );
+ CHSPSInstaller* installer = CHSPSInstaller::NewL( *this );
+ installer->InstallationHandler().DisableNotifications();
+ CleanupStack::PushL( installer );
+ for ( TInt i = 0; i < files.Count(); i++ )
+ {
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::InstallRestoredConfigurationsL(): - Install configuration: %S" ), &files[ i ] );
+#endif
+ TRAP( err, installer->InstallConfigurationL( files[ i ] ) );
+#ifdef HSPS_LOG_ACTIVE
+ if ( err != KErrNone )
+ {
+ iLogBus->LogText( _L( "ChspsThemeServer::InstallRestoredConfigurationsL(): - Installation failed: %S" ), &files[ i ] );
+ }
+#endif
+ }
+ CleanupStack::PopAndDestroy( installer );
+ CleanupStack::PopAndDestroy( &files );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::RestoreApplicationConfigurationsL()
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::RestoreApplicationConfigurationsL()
+ {
+ // Get the list of application configuration files included
+ // backup/themes directory
+ RArray <TFileName> files;
+ CleanupClosePushL( files );
+ hspsServerUtil::FindFilesL(
+ KBackupThemesDirectoryC,
+ KConfFile,
+ files );
+
+ // Get application configuration ODT's
+ TInt err( KErrNone );
+ CArrayPtrSeg<ChspsODT>* odts =
+ new ( ELeave )CArrayPtrSeg<ChspsODT>( KHeaderListGranularity );
+ CleanupStack::PushL( TCleanupItem( ResetAndDestroyChspsODTArray, odts ) );
+
+ for ( TInt i = 0; i < files.Count(); i++ )
+ {
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::RestoreApplicationConfigurationsL(): - Read application configuration ODT: %S" ), &files[ i ] );
+#endif
+ ChspsODT* odt = ChspsODT::NewL();
+ CleanupStack::PushL( odt );
+ TRAP( err, iDefinitionRepository->GetOdtL( files[ i ], *odt ) );
+ if ( err == KErrNone )
+ {
+ // Add ODT to ODT list
+ odts->AppendL( odt );
+ CleanupStack::Pop( odt );
+ }
+ else
+ {
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::RestoreApplicationConfigurationsL(): - Application configuration ODT reading faild: %S" ), &files[ i ] );
+#endif
+ CleanupStack::PopAndDestroy( odt );
+ }
+ }
+
+ // Validate application configurations
+ for ( TInt i = 0; i < odts->Count(); i++ )
+ {
+ ChspsODT* odt = odts->At( i );
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::RestoreApplicationConfigurationsL(): - Validate applicartion configuration: %S" ), &odt->ThemeFullName() );
+#endif
+ TRAP( err, ValidateRestoredConfigurationL( *odt ) );
+ if ( err == KErrNone )
+ {
+ // Restore application configuration
+ RestoreConfigurationL( *odt );
+ }
+ else
+ {
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::RestoreApplicationConfigurationsL(): - Validation failed: %S" ), &odt->ThemeFullName() );
+#endif
+ }
+ }
+
+ CleanupStack::PopAndDestroy( odts );
+ CleanupStack::PopAndDestroy( &files );
+
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::ValidateRestoredConfigurationL()
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::ValidateRestoredConfigurationL(
+ ChspsODT& aOdt )
+ {
+
+ // Validate application configuration
+ TBuf8<10> appConfUid;
+ _LIT8( KFormat8, "%X" );
+ _LIT8( KHexPrefix, "0x" );
+ appConfUid.Append( KHexPrefix );
+ appConfUid.AppendFormat( KFormat8, aOdt.ThemeUid() );
+ TPtrC8 appConfState;
+ hspsServerUtil::GetAttributeValueL(
+ aOdt,
+ KConfigurationElement,
+ KConfigurationAttrUid,
+ appConfUid,
+ KConfigurationAttrState,
+ appConfState );
+
+ if ( appConfState.Compare( KConfStateError ) == 0 )
+ {
+ // Invalid application configuration
+ User::Leave( KErrGeneral );
+ }
+
+ // Check application configuration version
+ ChspsODT* searchMask = ChspsODT::NewL();
+ CleanupStack::PushL( searchMask );
+ searchMask->SetThemeUid( aOdt.ThemeUid() );
+ ChspsODT* header( NULL );
+ TInt pos( 0 );
+ GetConfigurationHeader( *searchMask, header, pos );
+ if ( !header )
+ {
+ User::Leave( KErrNotFound );
+ }
+ else
+ {
+ hspsServerUtil::CheckConfigurationVersionL(
+ aOdt,
+ aOdt.ThemeUid(),
+ header->ThemeVersion() );
+ }
+ CleanupStack::PopAndDestroy( searchMask );
+
+ // Validate included plugins
+ // Get configuration UIDs from restored configuration
+ RArray <TInt> uids;
+ CleanupClosePushL( uids );
+ hspsServerUtil::FindUniquePluginsL(
+ aOdt,
+ uids );
+
+ for ( TInt i = 0; i < uids.Count(); i++ )
+ {
+ // Check if the configuration is installed
+ TInt err( KErrNone );
+ ChspsODT* searchMask = ChspsODT::NewL();
+ CleanupStack::PushL( searchMask );
+ searchMask->SetThemeUid( uids[ i ] );
+ ChspsODT* header( NULL );
+ TInt pos( 0 );
+ GetConfigurationHeader( *searchMask, header, pos );
+ if ( !header ) // Configuration not found
+ {
+ err = KErrNotFound;
+ }
+ else // Configuration found
+ {
+ // Check the configuration version
+ TPtrC8 version;
+ TRAP( err, hspsServerUtil::CheckConfigurationVersionL(
+ aOdt,
+ uids[ i ],
+ header->ThemeVersion() ) );
+ if ( err == KErrNone )
+ {
+ // Check that configuration resource files are found
+ TRAP( err, hspsServerUtil::CheckResourceFilesL(
+ aOdt,
+ uids[ i ] ) );
+ }
+ }
+
+ // Check configuration state attribute
+ // Configuration UID as HEX string
+ // 10 -> TInt as 0xXXXXXXXX string
+ TBuf8<10> confUid;
+ _LIT8( KFormat8, "%X" );
+ _LIT8( KHexPrefix, "0x" );
+ confUid.Append( KHexPrefix );
+ confUid.AppendFormat( KFormat8, uids[ i ] );
+ TPtrC8 state;
+ hspsServerUtil::GetAttributeValueL(
+ aOdt,
+ KConfigurationElement,
+ KConfigurationAttrUid,
+ confUid,
+ KConfigurationAttrState,
+ state );
+
+ if ( err != KErrNone )
+ {
+ // Set plugin configuration to "error" state
+ state.Set( KConfStateError );
+
+ // Remove missing plugins, thus there will be no error note later on
+ hspsServerUtil::RemovePluginResourcesL( aOdt, uids[ i ] );
+
+ }
+ else if ( state.CompareF( KConfStateError ) != 0 )
+ {
+ state.Set( KConfStateNotConfirmed );
+ }
+ hspsServerUtil::SetAttributeValueL(
+ aOdt,
+ KConfigurationElement,
+ KConfigurationAttrUid,
+ confUid,
+ KConfigurationAttrState,
+ state );
+
+ CleanupStack::PopAndDestroy( searchMask );
+ }
+
+ CleanupStack::PopAndDestroy( &uids );
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::RestoreConfigurationL()
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::RestoreConfigurationL(
+ ChspsODT& aOdt )
+ {
+
+ if ( iDefinitionRepository->Locked() )
+ {
+ User::Leave( KErrServerBusy );
+ }
+ iDefinitionRepository->Lock();
+ CleanupStack::PushL( TCleanupItem( UnlockRepository, iDefinitionRepository ) );
+
+ iDefinitionRepository->SetOdtL( aOdt );
+ // repository is unlocked in UnlockRepository function during PopAndDestroy
+ CleanupStack::PopAndDestroy();
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::ActivateThemeL()
+// -----------------------------------------------------------------------------
+//
+TInt ChspsThemeServer::ActivateThemeL(
+ const ChspsODT& aSetMask,
+ ChspsODT& aOdt )
+ {
+ TInt errorCode = GetConfigurationL(
+ aSetMask.RootUid(),
+ aSetMask.ThemeUid(),
+ aOdt );
+ if ( aOdt.ConfigurationType() != EhspsAppConfiguration )
+ {
+ errorCode = KErrArgument;
+ }
+
+ if( !errorCode )
+ {
+ const TUint32 KMask = 0xFFFFFFFF;
+ RArray<TUint32> res;
+ CleanupClosePushL( res );
+
+ iCentralRepository->FindL( aSetMask.RootUid(), KMask, res );
+ if ( res.Count() == 0 )
+ {
+ errorCode = iCentralRepository->Create( aSetMask.RootUid(), aSetMask.ThemeUid() );
+ }
+ else
+ {
+ errorCode = iCentralRepository->Set( aSetMask.RootUid(), aSetMask.ThemeUid() );
+ }
+ if ( !errorCode )
+ {
+ // Request re-evaluation of the new application configuration
+ hspsServerUtil::UpdateAppConfigurationStateL(
+ aOdt,
+ KConfStateConfirmed,
+ KConfStateNotConfirmed );
+
+ // Store changes to the Plug-in Repository
+ iDefinitionRepository->SetOdtL( aOdt );
+ }
+
+ res.Close();
+ CleanupStack::PopAndDestroy(); // res
+ }
+
+ return errorCode;
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::GetActivateAppConfigurationL()
+// -----------------------------------------------------------------------------
+//
+TInt ChspsThemeServer::GetActivateAppConfigurationL(
+ const TInt aAppUid,
+ ChspsODT& aOdt )
+ {
+ // Get active application configuration for the provided application
+ TInt configurationUid = -1;
+ TInt errorCode = iCentralRepository->Get(
+ aAppUid,
+ configurationUid );
+ if ( !errorCode )
+ {
+ __ASSERT_DEBUG( configurationUid > 0, User::Leave( KErrArgument) );
+
+ // Get the ODT object
+ errorCode = GetConfigurationL(
+ aAppUid,
+ configurationUid,
+ aOdt );
+
+ __ASSERT_DEBUG( aOdt.ConfigurationType() == EhspsAppConfiguration, User::Leave( KErrArgument) );
+ }
+
+ return errorCode;
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::GetActiveFamilyL()
+// -----------------------------------------------------------------------------
+//
+TUint32 ChspsThemeServer::GetActiveFamilyL(
+ const TInt aAppUid )
+ {
+ if ( aAppUid < 1 )
+ {
+ User::Leave( KErrArgument );
+ }
+ TUint32 familyMask( 0 );
+ ChspsODT* appODT = ChspsODT::NewL();
+ CleanupStack::PushL( appODT );
+ if ( !GetActivateAppConfigurationL( aAppUid, *appODT ) )
+ {
+ familyMask = appODT->Family();
+ }
+ CleanupStack::PopAndDestroy( appODT );
+ return familyMask;
+ }
+
+#if defined(WINSCW) || defined(__WINS__)
+void ChspsThemeServer::ActivateRootConfigurationsL()
+ {
+ // Get family from the active resolution
+ const ThspsFamily family = iFamily->GetFamilyType();
+
+ // Try to activate an application configuration which was designed
+ // for the active resolution
+ if ( !HandleFamilyChangeL( family ) )
+ {
+ // Try default family or just use the last one installed
+ HandleFamilyChangeL( KDefaultFamily );
+ }
+ }
+#endif // defined(WINSCW) || defined(__WINS__)
+
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::HandleFamilyChangeL()
+// -----------------------------------------------------------------------------
+//
+TBool ChspsThemeServer::HandleFamilyChangeL(
+ const ThspsFamily aNewFamily )
+ {
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::HandleFamilyChangeL(): resolution has changed, notifying clients..." ) );
+#endif // HSPS_LOG_ACTIVE
+
+ __ASSERT_DEBUG( aNewFamily > EhspsFamilyUnknown && aNewFamily <= EhspsFamilyVga_tch, User::Leave( KErrArgument) );
+
+ RArray<ChspsODT*> notificationTargets;
+ CleanupClosePushL( notificationTargets );
+
+ if ( iDefinitionRepository->Locked() )
+ {
+ User::Leave( KErrAccessDenied );
+ }
+ // In case of error. repository is unlocked
+ iDefinitionRepository->Lock();
+ CleanupStack::PushL( TCleanupItem( UnlockRepository, iDefinitionRepository ) );
+
+ // Find first application configurations with the provided family id
+ ChspsODT* header = NULL;
+ ChspsODT* targetHeader = NULL;
+ for ( TInt headerIndex=0; headerIndex < iHeaderListCache->Count(); headerIndex++ )
+ {
+ header = iHeaderListCache->At( headerIndex );
+
+ // It's totally acceptable that all clients haven't got resolution specific widgets,
+ // in that case the UI should remaing the same - others should reload the application configuration
+ // when appropriate for them
+ if ( header->ConfigurationType() == EhspsAppConfiguration )
+ {
+
+ // If the bit is set
+ if ( header->Family() & aNewFamily )
+ {
+
+ // Skip family change if it's already up to date
+ TInt activeConfigurationUid = -1;
+ const TInt err = iCentralRepository->Get( header->RootUid(), activeConfigurationUid );
+ if( err )
+ {
+ continue;
+ }
+
+ // Notify each client only once
+ TBool alreadyIncluded = EFalse;
+ for( TInt targetIndex=0; targetIndex < notificationTargets.Count(); targetIndex++ )
+ {
+ targetHeader = notificationTargets[ targetIndex ];
+ if ( header->RootUid() == targetHeader->RootUid() )
+ {
+ alreadyIncluded = ETrue;
+ break;
+ }
+ }
+ if ( !alreadyIncluded )
+ {
+ notificationTargets.Append( header );
+
+ // Check if active configuration supports the current family
+ TBool updateRequired = ETrue;
+ for( TInt i=0; i < iHeaderListCache->Count(); i++ )
+ {
+ ChspsODT* h = iHeaderListCache->At( i );
+ if( h->ThemeUid() == activeConfigurationUid )
+ {
+ if( (ThspsFamily)h->Family() & aNewFamily )
+ {
+ // No need to change the active root configuration
+ updateRequired = EFalse;
+ break;
+ }
+ }
+ }
+ if( updateRequired && activeConfigurationUid != header->ThemeUid() )
+ {
+ // Activate the resolution specific theme
+ ChspsODT* newOdt = ChspsODT::NewL();
+ CleanupStack::PushL( newOdt );
+ ActivateThemeL( *header, *newOdt );
+ CleanupStack::PopAndDestroy( newOdt );
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText(
+ _L( "ChspsThemeServer::HandleFamilyChangeL(): application configuration %D has been activated" ),
+ header->ThemeUid()
+ );
+#endif // HSPS_LOG_ACTIVE
+ }
+ } // updateRequired
+
+ } // header type
+
+ }
+
+ } // headers loop
+
+ iDefinitionRepository->Unlock();
+ CleanupStack::Pop(iDefinitionRepository);
+
+ // Signal that we found an application configuration for the requested family
+ TBool activated = ( notificationTargets.Count() > 0 );
+
+ // Reloading notifications are sent from void ChspsClientRequestHandler::HandleCenRepChangeL()
+ notificationTargets.Close();
+ CleanupStack::PopAndDestroy( ¬ificationTargets );
+
+#ifdef HSPS_LOG_ACTIVE
+ iLogBus->LogText( _L( "ChspsThemeServer::HandleFamilyChangeL(): notifications sent" ) );
+#endif // HSPS_LOG_ACTIVE
+
+ return activated;
+ }
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::Family()
+// -----------------------------------------------------------------------------
+//
+ChspsFamily* ChspsThemeServer::Family()
+ {
+ return iFamily;
+ }
+
+
+// -----------------------------------------------------------------------------
+// ChspsThemeServer::SetResourceFileCopyRequired()
+// -----------------------------------------------------------------------------
+//
+void ChspsThemeServer::SetResourceFileCopyRequired( const TInt aAppUid )
+ {
+ // Handle all related sessions
+ for( TInt i = 0; i < iSessions.Count(); i++ )
+ {
+ if( iSessions[i]->AppUid() == aAppUid )
+ {
+ iSessions[i]->SetResourceFileCopyRequired( ETrue );
+ }
+ }
+ }
+
+// end of file
+