--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/skins/AknSkins/srvsrc/AknsSrv.cpp Thu Dec 17 09:14:12 2009 +0200
@@ -0,0 +1,2934 @@
+/*
+* Copyright (c) 2002-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: Skin server core class.
+*
+*/
+
+
+// INCLUDE FILES
+#include "AknsSrv.h"
+
+#include <e32svr.h>
+#include <AknLayoutDef.h>
+#include <DRMHelper.h>
+#include <Oma2Agent.h>
+#include <bautils.h>
+#include <hal.h>
+#include <AknSkinsInternalCRKeys.h>
+#include <centralrepository.h>
+#include "tfxconfigparser.h"
+#include <TfxSrvEcomIds.h>
+#include <apgwgnam.h>
+
+
+#include "AknsSrvSettings.h"
+#include "AknsSrvScheduler.h"
+#include "AknsSkinContent.h"
+#include <AknsSkinUID.h>
+#include "AknsSrvUtils.h"
+#include "AknsSrvExclusion.h"
+#include "AknsSrvBitmapStore.h"
+#include "aknssrvwallpaperscaling.h"
+#include "aknssrvactivedataowner.h"
+#include "AknsDriveMaster.h"
+#include "aknssrviconconfigmap.h"
+
+#include "AknsDebug.h"
+
+_LIT(KTFxDefaultExtensionPath, "z:\\resource\\skins\\");
+_LIT(KTFxExtFileExt, ".sel");
+
+// Extension for ini file.
+_LIT( KAknsSkinSrvIniFileExt, ".ini" );
+
+// Extension for scalable vector graphics file.
+_LIT( KAknsSkinSrvSvgFileExt, ".svg" );
+
+// No wallpaper
+const TInt KAknsSkinSrvNoWallpaper = 0;
+// Image wallpaper
+const TInt KAknsSkinSrvImageWallpaper = 1;
+// Slideset wallpaper type
+const TInt KAknsSkinSrvSlidesetWallpaper = 2;
+
+// Filenames and locations of slideset ini-files.
+_LIT( KAknsSrvSSSSInifile, "\\private\\10207114\\SSSS.ini");
+_LIT( KAknsSrvSSWPInifile, "\\private\\10207114\\SSWP.ini");
+
+const TUint KSlidesetEnableAppUid[] = {
+ 0x100056cf, // ScreenSaver
+ 0x102750f0, // ActiveIdle
+ 0x10005a32, // Psln
+ 0x10207218, // CapServer
+ 0x00000000 // Empty
+ };
+
+// ============================ MEMBER FUNCTIONS ===============================
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::CAknsSrv
+// C++ constructor can NOT contain any code, that might leave.
+// -----------------------------------------------------------------------------
+//
+CAknsSrv::CAknsSrv() :
+ CServer2( CActive::EPriorityStandard),
+ iNotifyEnabled( ETrue ),
+ iContentChanged( EFalse ),
+ iOutstandingChangeEvents( 0 )
+ {
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::New
+// -----------------------------------------------------------------------------
+//
+CAknsSrv* CAknsSrv::New( TBool &aStartFailed )
+ {
+ AKNS_TRACE_INFO("CAknsSrv::New STARTED");
+
+ aStartFailed = EFalse;
+
+ CAknsSrv* server = new CAknsSrv();
+ server->iMergeType = (TAknsSkinSrvMergeType)(
+ EAknsSkinSrvSkin | EAknsSkinSrvIdleWp );
+ server->iBootFinished = EFalse;
+ if ( server )
+ {
+ if ( server->Start( KAknSkinSrvName ) != KErrNone )
+ {
+ AKNS_TRACE_ERROR("CAknsSrv::New START FAILED!");
+
+ aStartFailed = ETrue;
+ delete server;
+ return NULL;
+ }
+ }
+ else
+ {
+ AKNS_TRACE_ERROR("CAknsSrv::New SERVER ALLOCATION FAILED!");
+ return NULL;
+ }
+ server->iBitmapStore = new CAknsSrvBitmapStore;
+ if( !server->iBitmapStore )
+ {
+ AKNS_TRACE_ERROR("CAknsSrv::New BITMAPSTORE CREATION FAILED!");
+ delete server;
+ return NULL;
+ }
+ server->iChunkMaintainer =
+ new CAknsSrvChunkMaintainer(server->iBitmapStore);
+ if( !server->iChunkMaintainer )
+ {
+ AKNS_TRACE_ERROR("CAknsSrv::New CHUNK CREATION FAILED!");
+ delete server;
+ return NULL;
+ }
+
+ TInt err = server->iFsSession.Connect();
+ AKNS_TRACE_INFO1("CAknsSrv::New RFs connected, ret=%d", err);
+
+ AKNS_TRACE_INFO("CAknsSrv::New server up, connecting shared data");
+
+ TInt errorCode( KErrNone );
+ TRAP( errorCode, (server->iSettings=CAknsSrvSettings::NewL(server, server->iFsSession )) );
+ if( errorCode )
+ {
+ AKNS_TRACE_ERROR("CAknsSrv::New SETTING MANAGER CREATION FAILED!");
+ delete server;
+ return NULL;
+ }
+
+ AKNS_TRACE_INFO("CAknsSrv::New Settings manager created");
+
+ TRAPD( exlListErr, server->iExclusionList =
+ CAknsSrvExclusionList::NewL() );
+ AKNS_TRACE_INFO1("CAknsSrv::New Exclusion list init, ret=%d", exlListErr);
+ if( exlListErr == KErrNone )
+ {
+ TRAP( exlListErr, server->iExclusionList->LoadDefaultListFromFileL( server->iFsSession ) );
+ AKNS_TRACE_INFO1("CAknsSrv::New Exclusion list loaded, ret=%d", exlListErr);
+ if( exlListErr != KErrNone )
+ {
+ delete server->iExclusionList;
+ server->iExclusionList = NULL;
+ }
+ }
+
+ // Connection to Fbs-server is needed for server side bitmaps
+ // and should allways be kept connected.
+ err = server->iFbsSession.Connect();
+ AKNS_TRACE_INFO1("CAknsSrv::New FBS connected, ret=%d", err);
+
+ TRAP( errorCode, server->iSettings->InstallAdditionalWatchersL() );
+ AKNS_TRACE_INFO1("CAknsSrv::New Additional watchers installed, ret=%d", errorCode);
+
+ server->InitSlidesetEnableAppUid();
+
+ TRAP_IGNORE( server->InitMaxImageSizeL() );
+
+ TRAP( errorCode,server->iWallpaperCache = CAknsSrvWallpaperCache::NewL( KAknsWallpaperCacheSize ) );
+
+ AKNS_TRACE_INFO("CAknsSrv::New PrepareMergedSkinContentL");
+ TRAPD( mergeErr, server->PrepareMergedSkinContentL() );
+ if( mergeErr != KErrNone )
+ {
+ AKNS_TRACE_ERROR1("CAknsSrv::New MERGE ERROR %i", mergeErr);
+ server->SetDefaultSkinActive();
+ server->RestoreDefaultSDSettings();
+ TRAP( mergeErr, server->PrepareMergedSkinContentL() );
+ AKNS_TRACE_INFO1("CAknsSrv::New FALLBACK MERGE, ret=%d", mergeErr);
+ __ASSERT_DEBUG( mergeErr==KErrNone, User::Panic(
+ KAknSkinSrvPanicCategory, EAknsSrvFatalMergeFailure ) );
+ }
+
+ TRAP(err, server->iBackupSession = CBaBackupSessionWrapper::NewL() );
+ AKNS_TRACE_INFO1("CAknsSrv::New Backup session wrapper created, ret=%d", err);
+ if( server->iBackupSession )
+ {
+ TRAP(err, server->iBackupSession->RegisterBackupOperationObserverL(
+ *(server->iSettings) ) );
+ AKNS_TRACE_INFO1("CAknsSrv::New Backup observer registered, ret=%d", err);
+ }
+ TRAP( err, server->iBackupNotifier = CAknsSrvActiveDataOwner::NewL( server->iFsSession ) );
+ AKNS_TRACE_INFO1("CAknsSrv::New Backup notifier created, ret=%d", err);
+
+ AKNS_TRACE_INFO("CAknsSrv::New COMPLETED");
+
+ TRAP(err,server->iInstallObserver = CAknsSrvFileObserver::NewL(server));
+ server->iInstallObserver->IssueRequest();
+
+ server->iMergeType = EAknsSkinSrvNone;
+ server->iBootFinished = ETrue;
+ server->iWallpaperType = server->iSettings->WallpaperType();
+
+
+ return server;
+ }
+
+// -----------------------------------------------------------------------------
+// Destructor.
+// -----------------------------------------------------------------------------
+//
+CAknsSrv::~CAknsSrv()
+ {
+ // In theory we should never get here, since the server is always running.
+
+ delete iWPFilename;
+ iWPFilename = NULL;
+
+ if( iBackupSession )
+ {
+ iBackupSession->DeRegisterBackupOperationObserver( *iSettings );
+ delete iBackupSession;
+ iBackupSession = NULL;
+ }
+ delete iExclusionList;
+ delete iSettings;
+ delete iInstallObserver;
+ delete iWallpaperObserver;
+ iFbsSession.Disconnect();
+ iFsSession.Close();
+ iSknFile.Close();
+
+ delete iDrmHelper;
+ delete iBitmapStore;
+ delete iChunkMaintainer;
+ delete iSkinContentUri;
+ delete iIdleWPContentUri;
+ delete iSkinContentUri2;
+ delete iIdleWPContentUri2;
+
+ delete iWallpaperTimer;
+
+ delete iSlideSetObserver;
+ if ( iSlideSetNameArray )
+ {
+ iSlideSetNameArray->Reset();
+ }
+ delete iSlideSetNameArray;
+ delete iBackupNotifier;
+ delete iIconConfigMap;
+
+ iWallpaperCache->ResetAndDestory( );
+
+ iSlidesetEnableAppUidArray.Close();
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::NewSessionL
+// -----------------------------------------------------------------------------
+//
+CSession2* CAknsSrv::NewSessionL(const TVersion& aVersion, const RMessage2& /*aMessage*/) const
+ {
+ // Check that we're the right version
+ TVersion v( KAknSkinSrvMajorVersionNumber,
+ KAknSkinSrvMinorVersionNumber,
+ KAknSkinSrvBuildVersionNumber);
+ if ( !User::QueryVersionSupported(v, aVersion) )
+ {
+ User::Leave( KErrNotSupported );
+ }
+ // Make a new session
+ return new(ELeave) CAknsSrvSession( );
+ }
+
+// -----------------------------------------------------------------------------
+// CAknSkinSrv::ThreadStart()
+// The skin server thread.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TInt CAknsSrv::ThreadStart()
+ {
+ // Rename own thread
+ User::RenameThread(KAknSkinSrvName);
+
+ CAknsSrv* server = NULL;
+ CTrapCleanup* cleanup = CTrapCleanup::New();
+ CActiveScheduler* scheduler = new CAknsSrvScheduler;
+ TInt err(KErrNone);
+
+ TBool startFailed(EFalse);
+
+ if ( cleanup && scheduler )
+ {
+ CActiveScheduler::Install( scheduler );
+ server = CAknsSrv::New( startFailed ); // Adds server in scheduler
+ }
+
+ if ( !cleanup || !scheduler || !server )
+ {
+ delete cleanup;
+ delete scheduler;
+ delete server;
+
+ err = KErrNoMemory;
+
+ if(startFailed)
+ {
+ // Server Start call failed (means really that the server already existed)
+ err = KErrAlreadyExists;
+ }
+
+ }
+ if ( err == KErrNone )
+ {
+ // Prevent killing skin server from other processes
+ User::SetProcessCritical(User::ESystemCritical);
+ User::SetCritical(User::ESystemCritical);
+
+ // Signal that we've started
+ RProcess::Rendezvous(KErrNone);
+
+ // Start fielding requests from clients
+ CActiveScheduler::Start();
+
+ // Comes here if server gets shut down
+ delete scheduler; //lint !e644 Initialized
+ delete cleanup; //lint !e644 Initialized
+ delete server; //lint !e644 Initialized
+ }
+
+ // Thread/process exit
+ return( err );
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::NotifyBackupOperationEnd
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::NotifyBackupOperationEnd()
+ {
+ RestoreOldSkin();
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::NotifyLayoutChange
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::NotifyLayoutChange(TBool aClearScalable)
+ {
+#ifdef __WINS__
+// for emulator only, flush the cache also as
+// it is possible to perform "illegal" layout changes
+// ie. landscape -> landscape
+
+ if (aClearScalable)
+ {
+ iChunkMaintainer->ClearScalableGraphics(EAknsSrcScrModeNone);
+ }
+
+#endif // __WINS__
+ iContentChanged = ETrue;
+
+ if( !iSettings->CachedBackupOperationInProgress() )
+ {
+ MergeAndBroadcast();
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::NotifySkinChange
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::NofifySkinChange()
+ {
+ if (iUSBAttached)
+ {
+ return;
+ }
+ iContentChanged = ETrue;
+
+ if( !iSettings->CachedBackupOperationInProgress() )
+ {
+ MergeAndBroadcast();
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::NotifyIdleBackgroundChange
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::NotifyIdleBackgroundChange()
+ {
+ iContentChanged = ETrue;
+ iMergeType = (TAknsSkinSrvMergeType)(iMergeType | EAknsSkinSrvIdleWp);
+
+ if( !iSettings->CachedBackupOperationInProgress() )
+ {
+ MergeAndBroadcast();
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::NotifyDRMChange
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::NotifyDRMChange()
+ {
+ TRAP_IGNORE ( NotifyDRMChangeL() );
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::NotifyDRMChangeL
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::NotifyDRMChangeL()
+ {
+ AKNS_TRACE_INFO("CAknsSrv::NofifyDRMChange - DrmHelper notification");
+ CheckAndCreateDRMHelper();
+
+ TInt size = 256;
+ HBufC* buf = HBufC::NewLC(size);
+ TPtr bufPtr = buf->Des();
+
+ TInt error = iSettings->ReadDRMHelperServerNotification( bufPtr );
+ AKNS_TRACE_INFO1("CAknsSrv::NofifyDRMChange - ReadDRMHelperServerNotification: %d", error );
+
+ HBufC8* buf8 = HBufC8::New((buf->Length())*2);
+ CleanupStack::PushL(buf8);
+ const unsigned char* ptr = (const unsigned char*)(buf->Ptr());
+
+ buf8->Des().Copy(ptr,(buf->Length())*2);
+ TInt8 count = (TInt8)(*(buf8->Ptr()));
+ TChar mark = (TChar)(*(buf8->Ptr()+1));
+ TInt8 permtype = (TChar)(*(buf8->Ptr()+2));
+ TInt8 automcontenttype = (TChar)(*(buf8->Ptr()+3));
+ TBuf8<256> curi = buf8->Right( buf8->Length()-4);
+ if (curi.Ptr()[curi.Size()-1] == 0)
+ {
+ // The last character in the descriptor is 0, which means
+ // that the original 16-bit desc was padded so
+ // remove the last char...
+ curi.SetLength(curi.Size()-1);
+ }
+
+ if (mark == 'V')
+ {
+ AKNS_TRACE_INFO1("CAknsSrv::NotifyDRMChange DrmHelper notification type V received, count=%d",count);
+ if (count > 0)
+ {
+ if (iSkinContentUri && iSkinContentUri->Compare(curi) == 0)
+ {
+ AKNS_TRACE_INFO("CAknsSrv::NotifyDRMChange Skin is valid but about to expire");
+ iDrmHelper->SetAutomatedType(CDRMHelper::EAutomatedTypeTheme);
+ iDrmHelper->CheckRightsAmountL( *iSkinContentUri);
+ }
+ if ( iIdleWPContentUri && iIdleWPContentUri->Compare(curi) == 0)
+ {
+ AKNS_TRACE_INFO("CAknsSrv::NotifyDRMChange IdleWP is valid but about to expire");
+ iDrmHelper->SetAutomatedType(CDRMHelper::EAutomatedTypeWallpaper);
+ iDrmHelper->CheckRightsAmountL( *iIdleWPContentUri);
+ }
+ }
+ }
+ else if (mark == 'E')
+ {
+ AKNS_TRACE_INFO1("CAknsSrv::NotifyDRMChange DrmHelper notification type E received, count=%d",count);
+
+ if (count == 0)
+ {
+ // Expire skins here..., no note
+ if (iSkinContentUri && iSkinContentUri->Compare(curi) == 0)
+ {
+ AKNS_TRACE_INFO("CAknsSrv::NotifyDRMChange Skin is expired");
+ iSkinContentUri2 = (*iSkinContentUri).AllocL();
+ delete iSkinContentUri; iSkinContentUri = NULL;
+ RestoreDefaultSkin();
+ // Merge and broadcast
+ iContentChanged = ETrue;
+ MergeAndBroadcast();
+ // Also notify potential package list update
+ ForceNotifySessions(EAknsSCHNPackageListUpdate);
+ }
+ if (iIdleWPContentUri && iIdleWPContentUri->Compare(curi) == 0)
+ {
+ AKNS_TRACE_INFO("CAknsSrv::NotifyDRMChange IdleWP is expired");
+ iIdleWPContentUri2 = (*iIdleWPContentUri).AllocL();
+ delete iIdleWPContentUri;
+ iIdleWPContentUri = NULL;
+
+ if ( iWallpaperType == KAknsSkinSrvSlidesetWallpaper )
+ {
+ TBool isProtected = EFalse;
+ if ( iSlideSetNameArray && iSlideSetNameArray->MdcaCount() )
+ {
+ TFileName wallpaper;
+ iSettings->ReadIdleBackgroundFile( wallpaper );
+ CheckImageL( wallpaper, isProtected );
+ }
+ if ( isProtected )
+ {
+ iCurrentSlide = iCurrentSlide ? (iCurrentSlide - 1): (iSlideSetNameArray->MdcaCount() - 1);
+ WallpaperTimerTimeoutL( ETrue );
+ }
+ }
+ else
+ {
+ RestoreDefaultIdleWP();
+ // Merge and broadcast
+ iContentChanged = ETrue;
+ MergeAndBroadcast();
+ // Also notify potential package list update
+ ForceNotifySessions(EAknsSCHNPackageListUpdate);
+ }
+ }
+ }
+ else if (count > 0)
+ {
+ // Show expiration notes...
+ if (iSkinContentUri2 && iSkinContentUri2->Compare(curi) == 0)
+ {
+ AKNS_TRACE_INFO("CAknsSrv::NotifyDRMChange: RemoveAutomated called for skin");
+ iDrmHelper->SetAutomatedType(CDRMHelper::EAutomatedTypeTheme);
+ iDrmHelper->CheckRightsAmountL( *iSkinContentUri2);
+ User::LeaveIfError(iDrmHelper->RemoveAutomated( *iSkinContentUri2 ));
+ delete iSkinContentUri2;
+ iSkinContentUri2 = NULL;
+ }
+ if (iIdleWPContentUri2 && iIdleWPContentUri2->Compare(curi) == 0)
+ {
+ AKNS_TRACE_INFO("CAknsSrv::NotifyDRMChange: RemoveAutomated called for idlewp");
+ iDrmHelper->SetAutomatedType(CDRMHelper::EAutomatedTypeWallpaper);
+ iDrmHelper->CheckRightsAmountL( *iIdleWPContentUri2);
+ User::LeaveIfError(iDrmHelper->RemoveAutomated( *iIdleWPContentUri2 ));
+ delete iIdleWPContentUri2;
+ iIdleWPContentUri2 = NULL;
+ }
+ }
+ }
+
+ CleanupStack::PopAndDestroy(2); //buf, buf8
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::NotifySlideSetTimeoutChange
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::NotifySlideSetTimeoutChange()
+ {
+ // If timeout has not changed, then resume.
+ TInt newtimeout = iSettings->SlideSetWPTimeout();
+ if (iWallpaperTimer && iWallpaperTimer->Interval() == newtimeout)
+ {
+ return;
+ }
+ // only do this if slideset is selected
+ if ( iSettings->WallpaperType() == KAknsSkinSrvSlidesetWallpaper &&
+ iSlideSetNameArray )
+ {
+ TRAP_IGNORE( SetSlideSetTimerActiveL() );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::NotifySlideSetTypeChange
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::NotifySlideSetTypeChange()
+ {
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::NotifyWallpaperTypeChange
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::NotifyWallpaperTypeChange()
+ {
+ if ( iSlideSetObserver )
+ {
+ iSlideSetObserver->Cancel();
+ }
+ delete iSlideSetObserver;
+ iSlideSetObserver = NULL;
+
+ TInt newtype = iSettings->WallpaperType();
+ // do nothing if the type does not change
+ if (newtype != iWallpaperType)
+ {
+ // none
+ if ( newtype == KAknsSkinSrvNoWallpaper )
+ {
+ WallpaperLost();
+ }
+ // normal
+ else if ( newtype == KAknsSkinSrvImageWallpaper )
+ {
+ TFileName filename;
+ TInt error = iSettings->ReadIdleBackgroundFile( filename );
+ if( (error == KErrNone) && (filename.Length()>0))
+ {
+ if (AknsSrvUtils::IsFile( iFsSession, filename ) )
+ {
+ TRAP_IGNORE(
+ SetWallpaperL( filename,KAknsIIDWallpaper ) );
+ }
+ else
+ {
+ iSettings->WriteIdleBackgroundToDefault();
+ }
+ }
+ }
+ //slideset
+ else if ( newtype == KAknsSkinSrvSlidesetWallpaper )
+ {
+ TRAPD( err, SetSlidesetWallpaperL());
+ if ( err != KErrNone )
+ {
+ iSettings->WriteIdleBackgroundToDefault();
+ }
+ }
+ iWallpaperType = iSettings->WallpaperType();
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::NotifyScreenSaverChange
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::NotifyScreenSaverChange()
+ {
+ // If screensaver is now off => try to change the image.
+ TInt newValue = iSettings->ScreensaverState();
+ if ( newValue == 0 )
+ {
+ TRAP_IGNORE( WallpaperTimerTimeoutL() );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::NotifyTransitionFxChange
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::NotifyTransitionFxChange()
+ {
+ if (iSettings->TransitionFxState() == KMaxTInt)
+ {
+ StopTransitionSrv();
+ }
+ else
+ {
+ TRAPD(err,StartTransitionSrvL());
+ if (err)
+ {
+ StopTransitionSrv();
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::NotifyAnimEffectsChange
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::NotifyAnimBackgroundChange()
+ {
+ ForceNotifySessions( EAknsSCHNAnimBackgroundChanged );
+ }
+// -----------------------------------------------------------------------------
+// CAknsSrv::StartTransitionSrvL
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::StartTransitionSrvL(TBool aSkipSrvStart /*EFalse*/)
+ {
+ // if the transition server is running,
+ // shutdown it first in case TFX server start is not skipped
+ if (!aSkipSrvStart)
+ {
+ StopTransitionSrv();
+ User::LeaveIfError(iWsSession.Connect());
+ }
+
+ if ( ( iSettings->TransitionFxState() != KMaxTInt ) && LoadTfxSrvPluginL())
+ {
+ // If the server was already running unregister all the kml files
+ if (aSkipSrvStart)
+ {
+ if (!iTFXServer->IsConnected())
+ {
+ User::LeaveIfError(iTFXServer->Connect());
+ }
+ User::LeaveIfError(iTFXServer->UnregisterAllKml());
+ }
+ CTFXConfigParser* parser = CTFXConfigParser::NewL();
+ CleanupStack::PushL( parser );
+
+ TFileName transitionName;
+
+ // get active skin's transition
+ GetTransitionNameL( transitionName, iSettings->CachedSkinPID() );
+
+ TRAPD( err, StartSrvAndRegisterTransitionsL( transitionName,
+ iTFXServer,
+ iTFXServerCtrl,
+ parser,
+ aSkipSrvStart ) );
+ // base skin definition encountered
+ if( err == KBaseSkinParserLeave )
+ {
+ _LIT( KHexPrefix, "0x");
+ const TInt KUidLenght = 20;
+
+ TAknsPkgID baseSkinId = KAknsNullPkgID;
+ TBuf<KUidLenght> baseSkinDesc;
+ baseSkinDesc.Append( KHexPrefix );
+ baseSkinDesc.Append( parser->BaseSkinSelFile() );
+
+ TRAPD( err2, baseSkinId.SetFromDesL( baseSkinDesc ) );
+ if( err2 == KErrNone )
+ {
+ GetTransitionNameL( transitionName, baseSkinId );
+
+ // register base skin transitions
+ StartSrvAndRegisterTransitionsL( transitionName,
+ iTFXServer,
+ iTFXServerCtrl,
+ parser,
+ aSkipSrvStart );
+ }
+
+ // then register current skin's transitions
+ //(overrides base skin ones if overlapping)
+
+ GetTransitionNameL( transitionName, iSettings->CachedSkinPID() );
+
+ StartSrvAndRegisterTransitionsL( transitionName,
+ iTFXServer,
+ iTFXServerCtrl,
+ parser,
+ ETrue ); // server already running
+ }
+ else
+ {
+ User::LeaveIfError( err );
+ }
+ CleanupStack::PopAndDestroy( parser );
+ }
+ // if leave happens before this point, StopTransitionSrv is called
+ // which closes handle to tfxserver / deletes tfxserver ctrl
+ CloseTfxServerConnection();
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::StopTransitionSrv
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::StopTransitionSrv()
+ {
+ CloseTfxServerConnection();
+
+ if (iTFXServerCtrl)
+ {
+ iTFXServerCtrl->StopTransitionServer();
+ delete iTFXServerCtrl;
+ iTFXServerCtrl = NULL;
+
+ REComSession::DestroyedImplementation( iSrvControllerEComDtorUID );
+ iSrvControllerEComDtorUID.iUid = 0;
+ }
+
+ iWsSession.Close();
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::NotifyDriveChange
+//
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::NotifyDriveChange( const TInt& aDrive, const TBool& aMediaNotPresent )
+ {
+ // USB attachement is handled via other notifications.
+ if (iUSBAttached)
+ {
+ return;
+ }
+ if ( aMediaNotPresent && !iSettings->CachedBackupOperationInProgress())
+ {
+ if ( iSkinOnRemovableDrive && aDrive == iDriveIdOfRemovableDrive )
+ {
+ TAknsPkgID skinPID = iSettings->CachedSkinPID();
+ TBool excludeWP = EFalse;
+ if ( iSettings->WallpaperType() == KAknsSkinSrvSlidesetWallpaper )
+ {
+ excludeWP = ETrue;
+ }
+ SetDefaultSkinActive();
+ RestoreDefaultSDSettings(excludeWP);
+ MergeAndBroadcast();
+ }
+ else
+ {
+ // Set previous skin ID as NULL
+ iOldSkin = KAknsNullPkgID;
+ }
+ // Wallpaper was on removable drive and it is no longer accessible.
+ if ( iWPOnRemovableDrive && iWPFilename )
+ {
+ if ( !AknsSrvUtils::IsFile( iFsSession, *iWPFilename ) )
+ {
+ iWPOnRemovableDrive = EFalse;
+ WallpaperLost();
+ }
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::NotifyBackupOperationBegin
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::NotifyBackupOperationBegin()
+ {
+ BackupAndActiveDefaultSkin();
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::NotifyUSBAttach
+//
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::NotifyUSBAttach()
+ {
+ if (iUSBAttached)
+ {
+ return;
+ }
+ iUSBAttached = ETrue;
+
+ BackupAndActiveDefaultSkin();
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::NotifyUSBRemoval
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::NotifyUSBRemoval()
+ {
+ if (!iUSBAttached)
+ {
+ return;
+ }
+ iUSBAttached = EFalse;
+
+ RestoreOldSkin();
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::MorhphingEventTimeout
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::MorhphingEventTimeout()
+ {
+ if( iBootFinished )
+ {
+ iChunkMaintainer->ClearMorphedGraphics();
+ iChunkMaintainer->UpdateMorphingTime();
+ ForceNotifySessions(EAknsSCHNMorphingStateChange);
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::NewSkinPackagesInstalled
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::NewSkinPackagesInstalled()
+ {
+ if (iUSBAttached)
+ {
+ return;
+ }
+
+ ForceNotifySessions( EAknsSCHNPackageListUpdate );
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::WallpaperLost
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::WallpaperLost()
+ {
+ if ( iUSBAttached && iWPOnRemovableDrive )
+ {
+ return;
+ }
+ else if ( iSettings->WallpaperType() == KAknsSkinSrvSlidesetWallpaper )
+ {
+ TRAP_IGNORE( WallpaperTimerTimeoutL( ETrue ) );
+ return;
+ }
+ // Does not leave when removing wallpaper.
+ SetWallpaperL( KNullDesC, KAknsIIDWallpaper );
+ iSettings->WriteIdleBackgroundToDefault();
+ iMergeType = (TAknsSkinSrvMergeType)(iMergeType | EAknsSkinSrvIdleWp);
+ iContentChanged = ETrue;
+ BroadcastUpdate();
+ ForceNotifySessions( EAknsSCHNPackageListUpdate );
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::SlideSetModifiedL
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::SlideSetModifiedL()
+ {
+ // Read new file name array
+ ReadSlideSetImageFilesL();
+
+ SetSlideSetTimerActiveL();
+ // Try to get the first image.
+ WallpaperTimerTimeoutL( ETrue );
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::EnableSkinChangeNotify
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::EnableSkinChangeNotify()
+ {
+ // Only do something if the notificatio mechanism was disabled.
+ if (!iNotifyEnabled)
+ {
+ iNotifyEnabled = ETrue;
+ MergeAndBroadcast();
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::DisableSkinChangeNotify
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::DisableSkinChangeNotify()
+ {
+ iNotifyEnabled = EFalse;
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::BroadcastUpdate
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::BroadcastUpdate()
+ {
+ if ( iContentChanged )
+ {
+ iChunkMaintainer->RemoveSingleScalableItem(KAknsIIDWallpaper);
+ ForceNotifySessions( EAknsSCHNWallpaperChanged);
+ iContentChanged = EFalse;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::MergeAndBroadcast
+// -----------------------------------------------------------------------------
+//
+TInt CAknsSrv::MergeAndBroadcast()
+ {
+ TInt mergeErr = KErrNone;
+ // We don't want to notify anything if the mechanism was disabled.
+ if (iNotifyEnabled && iContentChanged)
+ {
+ iContentChanged = EFalse;
+ TRAP( mergeErr, PrepareMergedSkinContentL() );
+
+ if( mergeErr )
+ {
+ if( mergeErr==KErrNoMemory )
+ {
+ ForceNotifySessions( EAknsSCHNConfigurationOOM );
+ }
+ else
+ {
+ ForceNotifySessions( EAknsSCHNConfigurationCorrupt );
+ }
+
+ AKNS_TRACE_ERROR1("CAknsSrv::NotifySkinChangeToSessions MERGE ERROR %i", mergeErr);
+ SetDefaultSkinActive();
+ RestoreDefaultSDSettings();
+
+ // Error ignored, we can do nothing if default system skin does not merge
+ TRAP_IGNORE( PrepareMergedSkinContentL() );
+ }
+
+ iOutstandingChangeEvents +=
+ ForceNotifySessions( EAknsSCHNContentChanged, ETrue);
+ }
+ return mergeErr;
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::ForceNotifySessions
+// -----------------------------------------------------------------------------
+//
+TInt CAknsSrv::ForceNotifySessions(
+ const TAknsSkinChangeHandlerNotification aType, TBool aCountNotifications )
+ {
+ TInt queued(0);
+ iSessionIter.SetToFirst();
+ while( CSession2* session = iSessionIter++ )
+ {
+ if( (static_cast<CAknsSrvSession*>(session))->
+ EnqueueNotification( aType, aCountNotifications ) )
+ {
+ queued += 1;
+ }
+ }
+ return queued;
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::SetActiveSkinContent
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::SetActiveSkinContent(const TAknsPkgID aPID)
+ {
+ AKNS_TRACE_INFO2("CAknsSrv::SetActiveSkinContent %i %i", aPID.iNumber, aPID.iTimestamp );
+ iMergeType = (TAknsSkinSrvMergeType)(iMergeType | EAknsSkinSrvSkin);
+ iSettings->SetCachedSkinPID( aPID );
+ iContentChanged = ETrue;
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::PrepareMergedSkinContentL
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::PrepareMergedSkinContentL()
+ {
+ iChunkMaintainer->BeginWrite();
+
+ TRAPD( error, PrepareMergedSkinContentUnprotectedL() );
+
+ iChunkMaintainer->EndWrite();
+
+ if( error )
+ {
+ User::Leave( error );
+ }
+
+ StartAnimBackgroundL();
+
+ // Send notifications
+ ForceNotifySessions( EAknsSCHNConfigurationMerged );
+ iMergeType = EAknsSkinSrvNone;
+ iChunkMaintainer->CreateMorphingTimerL(this);
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::PrepareMergedSkinContentUnprotectedL
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::PrepareMergedSkinContentUnprotectedL()
+ {
+ iSkinOnRemovableDrive = EFalse;
+
+ iDriveIdOfRemovableDrive = KErrNotFound;
+
+ iChunkMaintainer->ResetLevel();
+
+ // Insert System default skin definitions first
+ DoMergeSkinL(
+ KAknsPIDS60DefaultSkin,
+ KAknsPIDS60DefaultSkin,
+ EAknsItemDefClassBitmaps,
+ ETrue, // clear
+ EFalse ); // override
+
+ iChunkMaintainer->NextLevel();
+
+ if (iSkinContentUri && (iMergeType & EAknsSkinSrvSkin))
+ {
+ CheckAndCreateDRMHelper();
+ if (!iSkinContentUri2)
+ {
+ // error ignored
+ if (iBootFinished)
+ {
+ iDrmHelper->SetAutomatedType(CDRMHelper::EAutomatedTypeTheme);
+ iDrmHelper->RemoveAutomated( *iSkinContentUri );
+ AKNS_TRACE_INFO("CAknsSrv - PrepareMergerSkinContentL: RemoveAutomated called for skin");
+ delete iSkinContentUri;
+ iSkinContentUri = NULL;
+ }
+ }
+ else if (iSkinContentUri->Compare(*iSkinContentUri2))
+ {
+ iDrmHelper->SetAutomatedType(CDRMHelper::EAutomatedTypeTheme);
+ iDrmHelper->RemoveAutomated( *iSkinContentUri );
+ AKNS_TRACE_INFO("CAknsSrv - PrepareMergerSkinContentL: RemoveAutomated called for skin");
+ delete iSkinContentUri;
+ iSkinContentUri = NULL;
+ }
+ }
+
+ if (iIdleWPContentUri && (iMergeType & EAknsSkinSrvIdleWp))
+ {
+ CheckAndCreateDRMHelper();
+ if (!iIdleWPContentUri2)
+ {
+ // error ignored
+ if (iBootFinished)
+ {
+ iDrmHelper->SetAutomatedType(CDRMHelper::EAutomatedTypeWallpaper);
+ iDrmHelper->RemoveAutomated( *iIdleWPContentUri );
+ AKNS_TRACE_INFO("CAknsSrv - PrepareMergerSkinContentL: RemoveAutomated called for idlewp");
+ delete iIdleWPContentUri;
+ iIdleWPContentUri = NULL;
+ }
+ }
+ else if (iIdleWPContentUri->Compare(*iIdleWPContentUri2))
+ {
+ iDrmHelper->SetAutomatedType(CDRMHelper::EAutomatedTypeWallpaper);
+ iDrmHelper->RemoveAutomated( *iIdleWPContentUri );
+ AKNS_TRACE_INFO("CAknsSrv - PrepareMergerSkinContentL: RemoveAutomated called for idlewp");
+ delete iIdleWPContentUri;
+ iIdleWPContentUri = NULL;
+ }
+ }
+
+ // And then, insert definitions from the selected skin...
+ if( iSettings->CachedSkinPID() != KAknsPIDS60DefaultSkin )
+ {
+ DoMergeSkinL(
+ iSettings->CachedSkinPID(), iSettings->CachedSkinPID(),
+ EAknsItemDefClassBitmaps, EFalse, EFalse );
+ }
+
+ iChunkMaintainer->NextLevel();
+
+ // Finally, check and merge wallpaper configuration
+
+ iChunkMaintainer->NextLevel();
+ if ( (!iUSBAttached) || ( iUSBAttached && !iWPOnRemovableDrive ) )
+ {
+ if ( iSettings->WallpaperType() == KAknsSkinSrvSlidesetWallpaper )
+ {
+ SetSlidesetWallpaperL();
+ }
+ else
+ {
+ TPath filename;
+ TInt error = iSettings->ReadIdleBackgroundFile( filename );
+ if( (error == KErrNone) && (filename.Length()>0))
+ {
+ if (AknsSrvUtils::IsFile( iFsSession, filename ) )
+ {
+ SetWallpaperL( filename,KAknsIIDWallpaper );
+ }
+ else
+ {
+ iSettings->WriteIdleBackgroundToDefault();
+ }
+ }
+ }
+ }
+
+ iChunkMaintainer->NextLevel();
+
+ // register effects if TfxSrvPlugin is available
+ TBool tfxServerRunning = (iTFXServerCtrl && iTFXServerCtrl->ServerRunning());
+ TRAPD(err,StartTransitionSrvL(tfxServerRunning));
+ if (err)
+ {
+ StopTransitionSrv();
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::DoMergeSkinL
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::DoMergeSkinL( const TAknsPkgID /*aSkinPID*/,
+ const TAknsPkgID aLocationPID, const TAknsItemDefClass aClass,
+ const TBool aClearTable, const TBool /*aAHOverrideSkin*/ )
+ {
+ AKNS_TRACE_INFO("CAknsSrv::DoMergeSkinL ENTERED");
+ TAknsSrvExclusionQuery query( iExclusionList );
+
+ // Add highlight animation variant status to query (to include/exclude
+ // animations in merging).
+ query.SetHighlightAnimEnabled( iSettings->HighlightAnimEnabled() );
+
+ AKNS_TRACE_INFO("CAknsSrv::DoMergeSkinL Non System skin");
+ // Normal skin
+ TBool isProtected = EFalse;
+
+ // First look from ROM drive.
+ TFileName path;
+ CAknsSrvDriveMaster::DefaultSkinDirectoryOnRom( path );
+ HBufC* skinfilename = AknsSrvUtils::GetSkinFileNameL( path, aLocationPID, iFsSession );
+ if ( !skinfilename )
+ {
+ AKNS_TRACE_INFO("CAknsSrv::DoMergeSkinL Skin was not found from ROM, trying static ones");
+ // Then from device drives.
+ CAknsSrvDriveMaster* driveMaster = iSettings->GetDriveMaster();
+ skinfilename = AknsSrvUtils::GetSkinFileNameL(
+ *driveMaster,
+ aLocationPID,
+ iFsSession,
+ CAknsSrvDriveMaster::EAknsSrvStaticDrive );
+ if( !skinfilename )
+ {
+ AKNS_TRACE_INFO("CAknsSrv::DoMergeSkinL Skin was not found from static drives, trying removable ones");
+ // Finally from removable drives.
+ skinfilename = AknsSrvUtils::GetSkinFileNameL(
+ *driveMaster,
+ aLocationPID,
+ iFsSession,
+ CAknsSrvDriveMaster::EAknsSrvRemovableDrive );
+ if ( !skinfilename )
+ {
+ AKNS_TRACE_ERROR("CAknsSrv::DoMergeSkinL Skin not found!");
+ // No skin was found at all...
+ User::Leave( KErrNotFound );
+ }
+ else
+ {
+ iSkinOnRemovableDrive = ETrue;
+ iFsSession.CharToDrive( skinfilename->Des()[0], iDriveIdOfRemovableDrive );
+ CleanupStack::PushL( skinfilename );
+ }
+ }
+ else
+ {
+ CleanupStack::PushL( skinfilename );
+ }
+ }
+ else
+ {
+ CleanupStack::PushL( skinfilename );
+ }
+#if defined(AKNS_TRACING_ENABLED_INFO)
+ if (skinfilename)
+ {
+ AKNS_TRACE_INFO1("CAknsSrv::DoMergeSkinL Skinfilename == %S", skinfilename);
+ }
+ else
+ {
+ AKNS_TRACE_INFO("CAknsSrv::DoMergeSkinL Skinfilename == NULL");
+ }
+#endif // AKNS_TRACING_ENABLED_INFO
+
+ RFile file;
+ User::LeaveIfError( file.Open(
+ iFsSession, *skinfilename, EFileRead | EFileShareReadersOnly));
+ CleanupClosePushL(file);
+
+ TFileName fn;
+ if (iSknFile.SubSessionHandle())
+ {
+ iSknFile.FullName(fn);
+ }
+
+ if (fn.CompareF(*skinfilename))
+ {
+ // file is not already open
+ iSknFile.Close();
+ iSknFile.Duplicate(file);
+ }
+
+ AKNS_TRACE_INFO("CAknsSrv::DoMergeSkinL SkinFilename got, checking protection...");
+ isProtected = AknsSrvUtils::IsDrmProtectedL(file);
+ if (isProtected)
+ {
+ AKNS_TRACE_INFO("CAknsSrv::DoMergeSkinL Skin is DRM-Protected");
+ // Get fileInfo
+ HBufC8* contenturi = AknsSrvUtils::GetContentUriFromFileL( *skinfilename );
+ AKNS_TRACE_INFO("CAknsSrv::DoMergeSkinLL - GetContentUriFromFileL returned succesfully");
+ CleanupStack::PushL(contenturi);
+
+ CheckAndCreateDRMHelper();
+ TBool canSetAutomated( EFalse );
+ TInt res = iDrmHelper->CanSetAutomated( *skinfilename, canSetAutomated );
+
+ if ( res == KErrCANoRights ||
+ res == KErrCANoPermission ||
+ !canSetAutomated )
+ {
+ AKNS_TRACE_ERROR1("CAknsSrv::DoMergeSkinL, failed due to CanSetAutomated result=%d, remove skin", res );
+ AKNS_TRACE_ERROR1("CAknsSrv::DoMergeSkinL, failed due to CanSetAutomated boolean=%d, remove skin", canSetAutomated );
+ if (!iBootFinished)
+ {
+ iSkinContentUri2 = contenturi->AllocL();
+ }
+ User::Leave(KErrCorrupt);
+ }
+
+ AKNS_TRACE_INFO("CAknsSrv::DoMergeSkinL - GetRightsInfo returned");
+ AKNS_TRACE_INFO("CAknsSrv::DoMergeSkin ENTERED");
+
+ if (!iSkinContentUri)
+ {
+ AKNS_TRACE_INFO("CAknsSrv::DoMergeSkinL - Picked up contenturi for automated content (SKIN)");
+ iSkinContentUri = contenturi->AllocL();
+ }
+
+ CleanupStack::PopAndDestroy(contenturi);
+ }
+ AKNS_TRACE_INFO("CAknsSrv::DoMergeSkinL DRM stuff done");
+ // Not sure if using mirroring flag works correctly here....
+ iChunkMaintainer->MergeSkinDefinitionsL(
+ *skinfilename, aClass, aClearTable, query,
+ iSettings->CachedAHMirroringActive(), aLocationPID );
+
+ CleanupStack::PopAndDestroy( 2, skinfilename );
+
+ AKNS_TRACE_INFO("CAknsSrv::DoMergeSkinL COMPLETED");
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::ActiveSkinAnimBgSupportL
+// -----------------------------------------------------------------------------
+//
+TBool CAknsSrv::ActiveSkinAnimBgSupportL( )
+ {
+ CAknsSrvChunkLookup* chunklookup = CAknsSrvChunkLookup::NewL();
+ CleanupStack::PushL( chunklookup );
+ TAknsItemID p;
+ p.Set(EAknsMajorProperty,EAknsMinorPropertyAnimBgParam);
+ CAknsItemDef* def = chunklookup->LookupAndCreateDefL( p );
+ CleanupStack::PopAndDestroy( chunklookup );
+ if ( def )
+ {
+ delete def;
+ return ETrue;
+ }
+
+ return EFalse;
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::ActiveSkinAnimBgParamL
+// -----------------------------------------------------------------------------
+//
+HBufC* CAknsSrv::ActiveSkinAnimBgParamL( )
+ {
+ HBufC* param = NULL;
+ CAknsSrvChunkLookup* chunklookup = CAknsSrvChunkLookup::NewL();
+ CleanupStack::PushL( chunklookup );
+ TAknsItemID p;
+ p.Set(EAknsMajorProperty,EAknsMinorPropertyAnimBgParam);
+ CAknsItemDef* def = chunklookup->LookupAndCreateDefL( p );
+ if ( def )
+ {
+ CleanupStack::PushL( def );
+ param = ((CAknsStringItemDef*)def)->String().AllocL();
+ CleanupStack::PopAndDestroy ( def );
+ }
+ CleanupStack::PopAndDestroy ( chunklookup );
+ return param;
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::StartAnimBackgroundL
+// -----------------------------------------------------------------------------
+void CAknsSrv::StartAnimBackgroundL()
+ {
+ if ( iSettings->TransitionFxState() == KMaxTInt )
+ {
+ //Stop anim effects
+ iSettings->SetAnimBackgroundState( KMaxTInt );
+ return;
+ }
+
+ const TUid KCRUidThemesVariation = { 0x102818EB };
+ const TUint32 KThemesLocalVariation = 0x00000001;
+
+ // Enable animated background setting.
+ // Bitmask value in decimals: 2048.
+ const TUint32 KPslnSupportAnimBackground = 0x00000800;
+
+ TInt value = 0;
+ CRepository* themeVar = CRepository::NewL( KCRUidThemesVariation );
+ TInt err = themeVar->Get( KThemesLocalVariation, value );
+ if ( err != KErrNone )
+ {
+ value = 0;
+ }
+ delete themeVar;
+
+ if ( (value & KPslnSupportAnimBackground) &&
+ ActiveSkinAnimBgSupportL()
+ )
+ {
+ //Start anim effects
+ iSettings->SetAnimBackgroundState( 0 );
+ }
+ else
+ {
+ //Stop anim effects
+ iSettings->SetAnimBackgroundState( KMaxTInt );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::SetWallpaperL
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::SetWallpaperL( const TDesC& aFilename,
+ const TAknsItemID& aIID, TBool aIsSlide )
+ {
+ if (iWallpaperType == KAknsSkinSrvNoWallpaper ||
+ iWallpaperType == KAknsSkinSrvImageWallpaper ||
+ !aIsSlide)
+ {
+ iCurrentSlide = 0;
+ WallpaperTimerL()->Stop();
+ }
+ if (!aIsSlide && iSlideSetNameArray)
+ {
+ delete iSlideSetNameArray;
+ iSlideSetNameArray = NULL;
+ }
+
+ if (aIID == KAknsIIDWallpaper)
+ {
+ iMergeType = (TAknsSkinSrvMergeType)(iMergeType | EAknsSkinSrvIdleWp);
+ }
+
+ if (iWallpaperObserver)
+ {
+ iWallpaperObserver->Cancel();
+ delete iWallpaperObserver;
+ iWallpaperObserver = NULL;
+ }
+
+ AKNS_TRACE_INFO("CAknsSrv::SetWallPaperL entered");
+ TBool isprotected = EFalse;
+ if (aFilename.Length() >0 )
+ {
+ CFbsBitmap* bmp = NULL;
+ CFbsBitmap* mask = NULL;
+ TInt err = KErrNone;
+
+ if ( !iWallpaperCache->IsCached( aFilename ) )
+ {
+ if ( aFilename.Right(4).CompareF( KAknsSkinSrvSvgFileExt ) != 0 )
+ {
+ TRAP( err, CAknsSrvImageConverter::DecodeImageL( iFsSession,
+ aFilename,
+ TSize(-1,-1),
+ bmp,
+ mask,
+ iMaxWallpaperSize ) );
+ }
+ delete bmp;
+ delete mask;
+ if ( err )
+ {
+ User::LeaveIfError( err );
+ }
+ }
+
+ isprotected = AknsSrvUtils::IsDrmProtectedL(aFilename);
+ if (!BaflUtils::FileExists(iFsSession, aFilename))
+ {
+ iSettings->WriteIdleBackgroundToDefault();
+ return;
+ }
+ }
+ if (isprotected)
+ {
+ CheckAndCreateDRMHelper();
+
+ // Get fileInfo
+ HBufC8* contenturi = AknsSrvUtils::GetContentUriFromFileL( aFilename );
+ CleanupStack::PushL(contenturi);
+ AKNS_TRACE_INFO("CAknsSrv::SetWallPaperL - GetFileInfo returned succesfully");
+
+ TBool canSetAutomated( EFalse );
+ TInt res = iDrmHelper->CanSetAutomated( aFilename, canSetAutomated );
+ if ( res == KErrCANoRights )
+ {
+ AKNS_TRACE_ERROR("CAknsSrv::SetWallPaperL - CanSetAutomated, result = KErrCANoRights");
+ RemoveAutomatedWallpaper(aIID, *contenturi);
+ CleanupStack::PopAndDestroy( contenturi );
+ return;
+ }
+
+ if ( res == KErrCANoPermission || !canSetAutomated )
+ {
+ AKNS_TRACE_ERROR("CAknsSrv::SetWallPaperL - ExpiredRights, FutureRights or ECountBased, remove wallpaper");
+ if (!iBootFinished)
+ {
+ if (aIID == KAknsIIDWallpaper)
+ {
+ AKNS_TRACE_INFO("CAknsSrv::SetWallpaperL - Picked up contenturi for automated content (idlewp)");
+ iIdleWPContentUri = contenturi->AllocL();
+ }
+ }
+ else
+ {
+ RemoveAutomatedWallpaper(aIID, *contenturi);
+ }
+ CleanupStack::PopAndDestroy( contenturi );
+ return;
+ }
+
+ AKNS_TRACE_INFO("CAknsSrv::SetWallPaperL - Wallpaper has valid restricted rights");
+ if (aIID == KAknsIIDWallpaper)
+ {
+ if (!iIdleWPContentUri)
+ {
+ AKNS_TRACE_INFO("CAknsSrv::SetWallpaperL - Picked up contenturi for automated content (idlewp)");
+ iIdleWPContentUri = contenturi->AllocL();
+ }
+ }
+
+ CleanupStack::PopAndDestroy(contenturi);
+ }
+
+ iChunkMaintainer->SetWallpaper( aIID, aFilename, 0);
+
+// Set the wallpaper type as correct.
+ if ( aFilename != KNullDesC && !aIsSlide )
+ {
+ iWallpaperType = KAknsSkinSrvImageWallpaper;
+ }
+ else if ( aFilename == KNullDesC && !aIsSlide )
+ {
+ iWallpaperType = KAknsSkinSrvNoWallpaper;
+ }
+
+ iContentChanged = ETrue;
+ if ( aFilename.Length() >0 )
+ {
+ TRAPD(err,iWallpaperObserver = CAknsSrvFileObserver::NewL(this, aFilename));
+ if (!err)
+ {
+ iWallpaperObserver->IssueRequest();
+ }
+ if ( CAknsSrvDriveMaster::IsRemovableDrive( iFsSession, aFilename ) )
+ {
+ iWPOnRemovableDrive = ETrue;
+ if ( iWPFilename )
+ {
+ delete iWPFilename;
+ iWPFilename = NULL;
+ }
+ iWPFilename = aFilename.AllocL();
+ }
+ else
+ {
+ iWPOnRemovableDrive = EFalse;
+ }
+ }
+ else
+ {
+ delete iWPFilename;
+ iWPFilename = NULL;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::CheckImageL
+// -----------------------------------------------------------------------------
+//
+TBool CAknsSrv::CheckImageL(const TDesC& aFilename, TBool& aIsProtected )
+ {
+ CFbsBitmap* bmp = NULL;
+ CFbsBitmap* mask = NULL;
+
+ TInt err = KErrNone;
+ if ( aFilename.Right(4).CompareF( KAknsSkinSrvSvgFileExt ) != 0 )
+ {
+ TRAP( err, CAknsSrvImageConverter::DecodeImageL( iFsSession,
+ aFilename,
+ TSize(-1,-1),
+ bmp,
+ mask,
+ iMaxWallpaperSize ) );
+ }
+ delete bmp;
+ delete mask;
+ if ( err )
+ {
+ return EFalse;
+ }
+
+ TBool isValidFile = ETrue;
+ aIsProtected = AknsSrvUtils::IsDrmProtectedL( aFilename );
+ if ( aIsProtected )
+ {
+ CheckAndCreateDRMHelper();
+
+ TBool canSetAutomated = EFalse;
+ TInt result = iDrmHelper->CanSetAutomated( aFilename, canSetAutomated );
+ if ( !canSetAutomated || result != KErrNone )
+ {
+ isValidFile = EFalse;
+ }
+ else
+ {
+ TBool expired = EFalse;
+ TBool sendAllowed = EFalse; //not needed
+ CDRMHelperRightsConstraints* playDrmHlpCons = NULL;
+ CDRMHelperRightsConstraints* dispDrmHlpCons = NULL;
+ CDRMHelperRightsConstraints* execDrmHlpCons = NULL;
+ CDRMHelperRightsConstraints* printDrmHlpCons = NULL;
+ iDrmHelper->GetRightsDetailsL(
+ aFilename,
+ ContentAccess::EView,
+ expired,
+ sendAllowed,
+ playDrmHlpCons,
+ dispDrmHlpCons,
+ execDrmHlpCons,
+ printDrmHlpCons );
+ delete playDrmHlpCons;
+ delete execDrmHlpCons;
+ delete printDrmHlpCons;
+ CleanupStack::PushL( dispDrmHlpCons );
+
+ if ( dispDrmHlpCons && dispDrmHlpCons->FullRights() )
+ {
+ isValidFile = ETrue;
+ }
+ CleanupStack::PopAndDestroy( dispDrmHlpCons );
+ }
+ }
+
+ return isValidFile;
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::WallpaperTimerTimeoutL
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::WallpaperTimerTimeoutL( TBool aForceChange )
+ {
+
+ TInt slideCount = 0;
+ if ( iSlideSetNameArray )
+ {
+ slideCount = iSlideSetNameArray->MdcaCount();
+ }
+ else
+ {
+ // Wallpaper slideset array has been deleted.
+ iSettings->WriteIdleBackgroundToDefault();
+ return;
+ }
+
+ if( !aForceChange && !CanChangeSlidesetWallpaperL() )
+ {
+ iCurrentSlide++;
+ if (iCurrentSlide >= slideCount)
+ {
+ iCurrentSlide = 0;
+ }
+ return;
+ }
+
+//Commnet out for bug ETTA-7JSDGE
+// if ( iSettings->ScreensaverState() > 0 )
+// {
+// iContentChanged = ETrue;
+// iCurrentSlide++;
+// if (iCurrentSlide >= slideCount)
+// {
+// iCurrentSlide = 0;
+// }
+// iSettings->StartScreenSaverListen();
+// return;
+// }
+
+ TInt freeRAM = 0;
+ HAL::Get(HALData::EMemoryRAMFree, freeRAM);
+ if (freeRAM < KAknSkinSrvFreeRAMNeeded)
+ {
+ return;
+ }
+
+ // Find next valid image.
+ TBool isProtected = EFalse;
+ while ( slideCount &&
+ ( !BaflUtils::FileExists(
+ iFsSession,
+ iSlideSetNameArray->MdcaPoint( iCurrentSlide ) ) ||
+ !CheckImageL(
+ iSlideSetNameArray->MdcaPoint( iCurrentSlide ),
+ isProtected ) ) )
+ {
+ iSlideSetNameArray->Delete(iCurrentSlide);
+ slideCount = iSlideSetNameArray->MdcaCount();
+ if (iCurrentSlide >= slideCount && slideCount > 0)
+ {
+ iCurrentSlide = 0;
+ TRAPD(err,{isProtected =
+ AknsSrvUtils::IsDrmProtectedL(iSlideSetNameArray->MdcaPoint(iCurrentSlide));}
+ );
+ if ( err != KErrNone )
+ {
+ isProtected = EFalse;
+ }
+ }
+ }
+
+ CheckAndCreateDRMHelper();
+
+ // @todo - remove automated content for previous slide - they don't use the member variable
+ // URI's.
+
+ // remove any previous automated content
+ if (iIdleWPContentUri)
+ {
+ iDrmHelper->SetAutomatedType(CDRMHelper::EAutomatedTypeWallpaper);
+ iDrmHelper->RemoveAutomated( *iIdleWPContentUri );
+ delete iIdleWPContentUri;
+ iIdleWPContentUri = NULL;
+ }
+
+ if (iIdleWPContentUri2)
+ {
+ iDrmHelper->SetAutomatedType(CDRMHelper::EAutomatedTypeWallpaper);
+ iDrmHelper->RemoveAutomated( *iIdleWPContentUri2 );
+ delete iIdleWPContentUri2;
+ iIdleWPContentUri2 = NULL;
+ }
+
+ // Set image as automated content.
+ if ( slideCount > iCurrentSlide && slideCount )
+ {
+ if ( isProtected )
+ {
+ iDrmHelper->SetAutomatedType(CDRMHelper::EAutomatedTypeWallpaper);
+ iDrmHelper->SetAutomatedSilent(iSlideSetNameArray->MdcaPoint(iCurrentSlide), ETrue);
+ iDrmHelper->ConsumeFile2(
+ iSlideSetNameArray->MdcaPoint( iCurrentSlide),
+ ContentAccess::EView,
+ CDRMHelper::EStart );
+ iDrmHelper->ConsumeFile2(
+ iSlideSetNameArray->MdcaPoint( iCurrentSlide),
+ ContentAccess::EView,
+ CDRMHelper::EFinish );
+ }
+ }
+
+ CRepository* skinsrep = CRepository::NewL(KCRUidPersonalisation);
+ CleanupStack::PushL(skinsrep);
+
+ if ( slideCount > 1 )
+ {
+ SetWallpaperL( iSlideSetNameArray->MdcaPoint(iCurrentSlide),KAknsIIDWallpaper, ETrue );
+ skinsrep->Set(KPslnIdleBackgroundImagePath, iSlideSetNameArray->MdcaPoint(iCurrentSlide));
+ iMergeType = (TAknsSkinSrvMergeType)(iMergeType | EAknsSkinSrvIdleWp);
+ iContentChanged = ETrue;
+ BroadcastUpdate();
+ iCurrentSlide++;
+ if ( iCurrentSlide >= slideCount )
+ {
+ iCurrentSlide = 0;
+ }
+ }
+ else
+ {
+ // only one or zero images left, cancel timer and set the wallpaper to normal
+ WallpaperTimerL()->Stop();
+ iCurrentSlide = 0;
+
+ TFileName fname;
+ if ( slideCount )
+ {
+ fname = iSlideSetNameArray->MdcaPoint(0);
+ }
+
+ if ( slideCount && BaflUtils::FileExists(iFsSession, fname) )
+ {
+ SetWallpaperL( fname,KAknsIIDWallpaper );
+ iWallpaperType = KAknsSkinSrvImageWallpaper;
+ User::LeaveIfError(skinsrep->Set(KPslnIdleBackgroundImagePath, fname));
+ User::LeaveIfError(skinsrep->Set(KPslnWallpaperType, iWallpaperType));
+ }
+ else
+ {
+ SetWallpaperL( KNullDesC,KAknsIIDWallpaper );
+ iSettings->WriteIdleBackgroundToDefault();
+ }
+
+ if ( iSlideSetNameArray )
+ {
+ iSlideSetNameArray->Reset();
+ }
+ delete iSlideSetNameArray;
+ iSlideSetNameArray = NULL;
+
+ iMergeType = (TAknsSkinSrvMergeType)(iMergeType | EAknsSkinSrvIdleWp);
+ iContentChanged = ETrue;
+ BroadcastUpdate();
+ }
+ CleanupStack::PopAndDestroy( skinsrep );
+ }
+
+// -----------------------------------------------------------------------------
+// Sets slide set wallpaper.
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::SetSlidesetWallpaperL( )
+ {
+ ReadSlideSetImageFilesL();
+
+ iWallpaperType = KAknsSkinSrvSlidesetWallpaper;
+
+ SetSlideSetTimerActiveL();
+
+ StopSlidesetIniFileObserver();
+ TFileName fileName;
+ CAknsSrvDriveMaster::GetDefaultDrive(
+ DriveInfo::EDefaultPhoneMemory, fileName );
+ fileName.Append( KAknsSrvSSWPInifile );
+
+ TAknsSrvFileSrvObserverType type = EAknsSrvFileObsSlidesetWallpaper;
+ iSlideSetObserver = CAknsSrvFileObserver::NewL( this, type, fileName );
+ iSlideSetObserver->IssueRequest();
+
+ WallpaperTimerTimeoutL();
+ }
+
+// -----------------------------------------------------------------------------
+// Sets slide set wallpaper.
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::StopSlidesetIniFileObserver( )
+ {
+ if ( iSlideSetObserver )
+ {
+ iSlideSetObserver->Cancel();
+ delete iSlideSetObserver;
+ iSlideSetObserver = NULL;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::StoreScalableGraphicsL
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::StoreScalableGraphicsL( const TAknsItemID& aIID,
+ const TInt aType, const TSize& aSize, TInt aBmpHandle, TInt aMskHandle, TBool aMorphing )
+ {
+ iChunkMaintainer->StoreScalableGraphicsL(
+ aIID, aType, aSize, aBmpHandle, aMskHandle, aMorphing);
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::ClearScalableGraphics
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::ClearScalableGraphics()
+ {
+ iChunkMaintainer->ClearScalableGraphics(EAknsSrvScrModeSquare);
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::FreeLayoutBitmaps
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::FreeLayoutBitmaps(const RMessage2 aMessage)
+ {
+ TAknsSrcScreenMode mode = (TAknsSrcScreenMode)aMessage.Int0();
+ iChunkMaintainer->ClearScalableGraphics(mode);
+ ForceNotifySessions( EAknsSCHNFlushClientSideCaches );
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::CheckIconConfigurationL
+// -----------------------------------------------------------------------------
+//
+TInt CAknsSrv::CheckIconConfiguration( const RMessage2 aMessage )
+ {
+ TUid appUid = TUid::Uid( 0 );
+ TPckg<TUid> appUidPack( appUid );
+ TBool isConfiguredIcon = EFalse;
+ TRAPD(err,
+ {aMessage.ReadL(0, appUidPack);
+ if ( !iIconConfigMap )
+ {
+ iIconConfigMap = CAknsSrvIconConfigMap::NewL();
+ }
+ iIconConfigMap->IsIconConfiguredL( appUid, isConfiguredIcon );}
+ );
+ if ( err != KErrNone)
+ {
+ err = isConfiguredIcon;
+ }
+ return isConfiguredIcon;
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::AcknowledgeNotification
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::AcknowledgeNotification( const TInt aType )
+ {
+ if( aType == EAknsSCHNContentChanged )
+ {
+ iOutstandingChangeEvents -= 1;
+ //__ASSERT_DEBUG( iOutstandingChangeEvents >= 0, User::Panic(
+ // KAknSkinSrvPanicCategory, EAknsSrvNotifyListImbalance ) );
+
+ if( iOutstandingChangeEvents == 0 )
+ {
+ // Clear scalable graphics
+ ClearScalableGraphics();
+
+ // Broadcast deployment notification
+ ForceNotifySessions( EAknsSCHNConfigurationDeployed );
+ }
+ if ( iOutstandingChangeEvents < 0 )
+ {
+ // Some client is spamming us with EAknSkinSrvAckNotification.
+ iOutstandingChangeEvents = 0;
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::OpenBitmapFileL
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::OpenBitmapFileL( const RMessage2 aMessage )
+ {
+ // message parameters
+ // 0. filename
+ // 1. filehandle
+ TFileName filename;
+ aMessage.ReadL( 0,filename );
+
+ if ( !filename.Length() )
+ {
+ User::Leave( KErrNotFound );
+ }
+
+ RFile file;
+ TChar driveLetter = filename[0];
+ TInt driveNumber;
+ User::LeaveIfError( iFsSession.CharToDrive( driveLetter, driveNumber ) );
+
+ User::LeaveIfError( iFsSession.ShareProtected() );
+ TInt err = iFsSession.CreatePrivatePath( driveNumber );
+
+ if ( err != KErrNone && err != KErrAlreadyExists )
+ {
+ User::Leave( err );
+ }
+
+ User::LeaveIfError( iFsSession.SetSessionToPrivate( driveNumber ) );
+
+ // @TODO the filename should probably be checked against the filenames
+ // in the chunkmaintainer
+
+ User::LeaveIfError( file.Open(
+ iFsSession, filename, EFileRead | EFileShareReadersOnly ) );
+ CleanupClosePushL( file );
+ User::LeaveIfError( file.TransferToClient( aMessage, 1 ) );
+
+ CleanupStack::PopAndDestroy(); // file, ownership transferred to client
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::OpenIniFileL
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::OpenIniFileL( const RMessage2 aMessage)
+ {
+ // Message parameters
+ // 0. package id
+ // 1. location
+ // 2. filehandle
+ // 3. openmode (EFalse = read, ETrue = write)
+ TFileName filename;
+ TFileName path;
+ TAknsPkgID pid = KAknsNullPkgID;
+ TPckg<TAknsPkgID> pidPack( pid );
+ aMessage.ReadL(0, pidPack);
+ TAknSkinSrvSkinPackageLocation location =(TAknSkinSrvSkinPackageLocation)aMessage.Int1();
+ TBool openmode = aMessage.Int3(); // todo read this from client
+
+ if ( location == EAknsSrvPhone )
+ {
+ CAknsSrvDriveMaster::GetDefaultDrive( DriveInfo::EDefaultPhoneMemory, path );
+ if ( path.Length() > 0 )
+ {
+ path.Append( KAknSkinSrvPrivateSkinPath );
+ }
+ }
+ else if ( location == EAknsSrvMMC )
+ {
+ CAknsSrvDriveMaster::GetDefaultDrive( DriveInfo::EDefaultMassStorage, path );
+ if ( path.Length() > 0 )
+ {
+ path.Append( KAknSkinSrvPrivateSkinPath );
+ }
+ }
+ else
+ {
+ User::Leave(KErrArgument);
+ }
+
+ // this is the skin directory
+ path.AppendNumFixedWidthUC( pid.iNumber, EHex, 8 );
+ if( !pid.IsUid() )
+ {
+ path.AppendNumFixedWidthUC( pid.iTimestamp, EHex, 8 );
+ }
+ path.Append(KPathDelimiter);
+
+ RFile file;
+ User::LeaveIfError(iFsSession.ShareProtected());
+ TChar driveLetter = path[0];
+
+ TInt driveNumber;
+ User::LeaveIfError(iFsSession.CharToDrive(driveLetter, driveNumber));
+ TInt err=iFsSession.CreatePrivatePath(driveNumber);
+ if (err!=KErrNone && err!=KErrAlreadyExists)
+ {
+ User::Leave(err);
+ }
+ filename.AppendNumFixedWidthUC( pid.iNumber, EHex, 8 );
+ if( !pid.IsUid() )
+ {
+ filename.AppendNumFixedWidthUC( pid.iTimestamp, EHex, 8 );
+ }
+
+ filename.Append( KAknsSkinSrvIniFileExt );
+
+ User::LeaveIfError(iFsSession.SetSessionToPrivate(driveNumber));
+
+ iInstallObserver->Cancel();
+ if (openmode)
+ {
+ // open readwrite
+ err = iFsSession.MkDirAll(path);
+ path.Append(filename);
+ if (err == KErrNone || err == KErrAlreadyExists)
+ {
+ err = file.Replace(
+ iFsSession,path,
+ EFileShareExclusive | EFileStreamText | EFileWrite );
+ }
+ }
+ else
+ {
+ // open in read only mode
+ path.Append(filename);
+ err = file.Open( iFsSession, path, EFileStreamText | EFileRead );
+ }
+ iInstallObserver->IssueRequest();
+ User::LeaveIfError(err);
+ CleanupClosePushL(file);
+
+ User::LeaveIfError(file.TransferToClient(aMessage,2));
+ CleanupStack::PopAndDestroy(); // file, ownership transferred to client
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::OpenImageInifileL
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::OpenImageInifileL(const RMessage2 aMessage)
+ {
+ // Message parameters
+ // 0. filehandle
+ // 1. type
+ TAknsSrvInifileType inifiletype = (TAknsSrvInifileType)aMessage.Int1();
+
+ RFile file;
+ User::LeaveIfError(iFsSession.ShareProtected());
+ TInt driveNumber;
+
+ TFileName path;
+ CAknsSrvDriveMaster::GetDefaultDrive( DriveInfo::EDefaultPhoneMemory, path );
+ User::LeaveIfError(iFsSession.CharToDrive(path[0], driveNumber));
+
+ TInt err=iFsSession.CreatePrivatePath(driveNumber);
+ if (err!=KErrNone && err!=KErrAlreadyExists)
+ {
+ User::Leave(err);
+ }
+
+ User::LeaveIfError(iFsSession.SetSessionToPrivate(driveNumber));
+
+ TFileName fileName;
+ CAknsSrvDriveMaster::GetDefaultDrive(
+ DriveInfo::EDefaultPhoneMemory, fileName );
+
+ if (inifiletype == EAknsSrvInifileSSWP)
+ {
+ fileName.Append( KAknsSrvSSWPInifile );
+ err = file.Create(
+ iFsSession, fileName, EFileShareAny|EFileStreamText|EFileWrite );
+ if (err == KErrAlreadyExists)
+ {
+ User::LeaveIfError( file.Open(
+ iFsSession,
+ fileName,
+ EFileShareAny | EFileStreamText | EFileWrite ) );
+ }
+ }
+ else
+ {
+ fileName.Append( KAknsSrvSSSSInifile );
+ err = file.Create(
+ iFsSession, fileName, EFileShareAny|EFileStreamText|EFileWrite );
+ if (err == KErrAlreadyExists)
+ {
+ User::LeaveIfError( file.Open(
+ iFsSession,
+ KAknsSrvSSSSInifile,
+ EFileShareAny | EFileStreamText | EFileWrite ) );
+ }
+ }
+ CleanupClosePushL(file);
+
+ User::LeaveIfError(file.TransferToClient(aMessage,0));
+ CleanupStack::PopAndDestroy(); // file, ownership transferred to client
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::CopySoundFileL
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::CopySoundFileL(const RMessage2 aMessage)
+ {
+ TFileName sourcefilename;
+ TFileName targetfilename;
+ aMessage.ReadL( 0,sourcefilename );
+ aMessage.ReadL( 1,targetfilename );
+ CFileMan* fileMan = CFileMan::NewL( iFsSession );
+ CleanupStack::PushL(fileMan);
+ User::LeaveIfError(
+ fileMan->Copy(
+ sourcefilename,
+ targetfilename,
+ CFileMan::ERecurse | CFileMan::EOverWrite ) );
+ CleanupStack::PopAndDestroy( fileMan );
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::EnumeratePackages
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::EnumeratePackages( const RMessage2 aMessage)
+ {
+ TRAP_IGNORE( EnumeratePackagesL( aMessage ) );
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::EnumeratePackagesL
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::EnumeratePackagesL( const RMessage2 aMessage)
+ {
+ AKNS_TRACE_INFO("CAknsSrv::EnumeratePackagesL Begin");
+ TAknSkinSrvSkinPackageLocation location = (TAknSkinSrvSkinPackageLocation)aMessage.Int1();
+ if (iPackageArray)
+ {
+ iPackageArray->ResetAndDestroy();
+ delete iPackageArray;
+ iPackageArray = NULL;
+ }
+ iPackageArray = new (ELeave) CArrayPtrFlat<TAknsSrvSkinInfoPkg>(5);
+ CDesC16ArrayFlat* skinfiles = new (ELeave) CDesC16ArrayFlat(5);
+ CleanupStack::PushL(skinfiles);
+
+ CAknsSrvDriveMaster* driveMaster = iSettings->GetDriveMaster();
+ TInt deviceDrives =
+ driveMaster->GetNumberOfDrives( CAknsSrvDriveMaster::EAknsSrvStaticDrive );
+ TInt massDrives =
+ driveMaster->GetNumberOfDrives( CAknsSrvDriveMaster::EAknsSrvRemovableDrive );
+
+ AKNS_TRACE_INFO1("CAknsSrv::EnumeratePackagesL device drives = %d", deviceDrives );
+ AKNS_TRACE_INFO1("CAknsSrv::EnumeratePackagesL mass drives = %d", massDrives );
+
+ TInt index = 0;
+ TFileName path;
+
+ switch (location)
+ {
+ // Drives z and c
+ case EAknsSrvPhone:
+ CAknsSrvDriveMaster::DefaultSkinDirectoryOnRom( path );
+ AknsSrvUtils::SearchDirectoriesL( iFsSession, path, skinfiles );
+ for ( ; index < deviceDrives; index++ )
+ {
+ driveMaster->SkinDirectoryOnDrive(
+ CAknsSrvDriveMaster::EAknsSrvStaticDrive, index, path );
+ AknsSrvUtils::SearchDirectoriesL( iFsSession, path, skinfiles );
+ }
+ break;
+ // drive e
+ case EAknsSrvMMC:
+ for ( ; index < massDrives; index++ )
+ {
+ driveMaster->SkinDirectoryOnDrive(
+ CAknsSrvDriveMaster::EAknsSrvRemovableDrive, index, path );
+ AknsSrvUtils::SearchDirectoriesL( iFsSession, path, skinfiles );
+ }
+ break;
+ // all drives
+ case EAknsSrvAll:
+ CAknsSrvDriveMaster::DefaultSkinDirectoryOnRom( path );
+ AknsSrvUtils::SearchDirectoriesL( iFsSession, path, skinfiles );
+ for ( ; index < deviceDrives; index++ )
+ {
+ driveMaster->SkinDirectoryOnDrive(
+ CAknsSrvDriveMaster::EAknsSrvStaticDrive, index, path );
+ AknsSrvUtils::SearchDirectoriesL( iFsSession, path, skinfiles );
+ }
+ index = 0;
+ for ( ; index < massDrives; index++ )
+ {
+ driveMaster->SkinDirectoryOnDrive(
+ CAknsSrvDriveMaster::EAknsSrvRemovableDrive, index, path );
+ AknsSrvUtils::SearchDirectoriesL( iFsSession, path, skinfiles );
+ }
+
+ break;
+ default: break;
+ }
+
+ AKNS_TRACE_INFO1("CAknsSrv::EnumeratePackagesL skin files found = %d", skinfiles->Count() );
+
+ CheckAndCreateDRMHelper();
+ AknsSrvUtils::BuildSkinInfoPackagesL(
+ iPackageArray, skinfiles, iFsSession, *iDrmHelper );
+
+ TInt count = iPackageArray->Count();
+ AKNS_TRACE_INFO1("CAknsSrv::EnumeratePackagesL packages found = %d", count );
+ TPtr8 countptr((TUint8*)(&count),4,4);
+ aMessage.WriteL( 0,countptr );
+ CleanupStack::Pop( skinfiles );
+ skinfiles->Reset();
+ delete skinfiles;
+ AKNS_TRACE_INFO("CAknsSrv::EnumeratePackagesL End");
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::ReceivePackages
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::ReceivePackages( const RMessage2 aMessage )
+ {
+ TInt pkgcount = aMessage.Int0();
+
+ for (TInt count= 0; count < pkgcount; count++)
+ {
+ if ( !iPackageArray )
+ {
+ // No package array.
+ break;
+ }
+ if ( iPackageArray->Count() == 0 )
+ {
+ // Package array is empty.
+ break;
+ }
+ if ( count >= iPackageArray->Count() )
+ {
+ // Out-of-bounds with package array.
+ break;
+ }
+ TPtr8 pkgptr((TUint8*)( iPackageArray->At(count)),
+ sizeof(TAknsSrvSkinInfoPkg),sizeof(TAknsSrvSkinInfoPkg));
+ aMessage.Write(1,pkgptr,count*sizeof(TAknsSrvSkinInfoPkg));
+ }
+ if ( iPackageArray )
+ {
+ iPackageArray->ResetAndDestroy();
+ }
+ delete iPackageArray;
+ iPackageArray = NULL;
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::DecodeWallpaperImageL
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::DecodeWallpaperImageL( const RMessage2 aMessage)
+ {
+ // message params
+ // 0 = filename
+ // 1 = size
+ // 2 = bmphandle
+ // 3 = maskhandle
+ TFileName filename;
+ TSize trgSize;
+ TPckg<TSize> sizePack( trgSize );
+ aMessage.ReadL(0, filename);
+ aMessage.ReadL(1, sizePack);
+
+ TAknsSrvWallpaper* wp;
+ wp = iWallpaperCache->AddL( iFsSession, filename, trgSize, iMaxWallpaperSize );
+
+ if ( !wp )
+ {
+ return;
+ }
+
+ TInt bmphandle = 0;
+ TInt mskhandle = 0;
+
+ if ( trgSize.iHeight >= trgSize.iWidth )
+ {
+ bmphandle = wp->iPortrait ? wp->iPortrait->Handle() : 0;
+ mskhandle = wp->iPortraitMask ? wp->iPortraitMask->Handle() : 0;
+ }
+ else
+ {
+ bmphandle = wp->iLandscape ? wp->iLandscape->Handle() : 0;
+ mskhandle = wp->iLandscapeMask ? wp->iLandscapeMask->Handle() : 0;
+ }
+
+ TPtr8 bmpptr((TUint8*)(&bmphandle), 4, 4);
+ TPtr8 mskptr((TUint8*)(&mskhandle), 4, 4);
+ if (wp->iPortrait || wp->iLandscape)
+ {
+ aMessage.Write(2,bmpptr);
+ }
+
+ aMessage.Write(3,mskptr);
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::CacheWallpaperImageL
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::CacheWallpaperImageL( const RMessage2 aMessage)
+ {
+ // message params
+ // 0 = filename
+ // 1 = size
+ // 2 = bmphandle
+ // 3 = maskhandle
+ TFileName filename;
+ TSize trgSize;
+ TPckg<TSize> sizePack( trgSize );
+ aMessage.ReadL(0, filename);
+ aMessage.ReadL(1, sizePack);
+
+ iWallpaperCache->AddL( iFsSession, filename, trgSize, iMaxWallpaperSize );
+ return;
+ }
+// -----------------------------------------------------------------------------
+// CAknsSrv::FreeDecodedWallpaper
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::FreeDecodedWallpaper( const RMessage2 aMessage )
+ {
+ TFileName filename;
+ aMessage.ReadL( 0, filename );
+ if ( filename.Length() )
+ {
+ iWallpaperCache->Remove( filename );
+ }
+ else
+ {
+ iWallpaperCache->ResetAndDestory( );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::RestoreDefaultSkin
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::RestoreDefaultSkin()
+ {
+ iMergeType = (TAknsSkinSrvMergeType)(iMergeType | EAknsSkinSrvSkin);
+
+ iSettings->WriteSkinToDefault();
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::RestoreDefaultIdleWP
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::RestoreDefaultIdleWP()
+ {
+ iMergeType = (TAknsSkinSrvMergeType)(iMergeType | EAknsSkinSrvIdleWp);
+
+ iSettings->WriteIdleBackgroundToDefault();
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::RemoveAutomatedWallpaper
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::RemoveAutomatedWallpaper(
+ const TAknsItemID aIID, const TDesC8& aContentUri )
+ {
+ CheckAndCreateDRMHelper();
+ if (!iUSBAttached)
+ {
+ iDrmHelper->SetAutomatedType(CDRMHelper::EAutomatedTypeWallpaper);
+ iDrmHelper->RemoveAutomated(aContentUri);
+ }
+ AKNS_TRACE_INFO("CAknsSrv - RemoveAutomatedWallpaperL: RemoveAutomated called for idlewp");
+ RestoreDefaultIdleWP();
+ iChunkMaintainer->SetWallpaper( aIID, KNullDesC(), 0 );
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::HandleClientError
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::HandleClientError( TInt aErrorCode )
+ {
+ AKNS_TRACE_INFO("CAknsSrv::HandleClientError called");
+ // Ignore all errors if backup operation is in progress....
+ if( iSettings->CachedBackupOperationInProgress() )
+ {
+ return;
+ }
+ // We cannot really do anything if the system default skin is
+ // already set.....
+ if( iSettings->CachedSkinPID() == iSettings->DefaultSkinPID() )
+ {
+ return;
+ }
+ else
+ {
+ TBool enabled = iNotifyEnabled;
+ EnableSkinChangeNotify();
+
+ if( aErrorCode==KErrNoMemory )
+ {
+ ForceNotifySessions( EAknsSCHNConfigurationOOM );
+ }
+ else
+ {
+ ForceNotifySessions( EAknsSCHNConfigurationCorrupt );
+ }
+
+ SetDefaultSkinActive();
+
+ // This merges the skin content:
+ MergeAndBroadcast();
+
+ // Package list might have changed as well
+ ForceNotifySessions( EAknsSCHNPackageListUpdate );
+
+ // Restore the notify mechanism to its original state so that
+ // clients do not get confused...
+ if (!enabled)
+ {
+ DisableSkinChangeNotify();
+ }
+
+ // Try to update values in shareddata also
+ RestoreDefaultSDSettings();
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::RestoreDefaultSDSettings()
+// Restores default shared data settings
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::RestoreDefaultSDSettings(TBool aExcludeWP)
+ {
+ AKNS_TRACE_ERROR("CAknsSrv::Skin not found, or other error encountered! Trying to restore default SD settings.");
+ if (!iUSBAttached)
+ {
+ RemoveAutomatedContent();
+ }
+ iSettings->WriteAllToDefault(aExcludeWP);
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::RemoveAutomatedContent
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::RemoveAutomatedContent()
+ {
+ // Remove all automated content
+ CheckAndCreateDRMHelper();
+ if (!iBootFinished)
+ {
+ return;
+ }
+ if (iSkinContentUri)
+ {
+ iDrmHelper->SetAutomatedType(CDRMHelper::EAutomatedTypeTheme);
+ iDrmHelper->RemoveAutomated( *iSkinContentUri );
+ delete iSkinContentUri;
+ iSkinContentUri = NULL;
+ }
+ if (iIdleWPContentUri)
+ {
+ iDrmHelper->SetAutomatedType(CDRMHelper::EAutomatedTypeWallpaper);
+ iDrmHelper->RemoveAutomated( *iIdleWPContentUri );
+ delete iIdleWPContentUri;
+ iIdleWPContentUri = NULL;
+ }
+ if (iSkinContentUri2)
+ {
+ iDrmHelper->SetAutomatedType(CDRMHelper::EAutomatedTypeTheme);
+ iDrmHelper->RemoveAutomated( *iSkinContentUri2 );
+ delete iSkinContentUri2;
+ iSkinContentUri2 = NULL;
+ }
+ if (iIdleWPContentUri2)
+ {
+ iDrmHelper->SetAutomatedType(CDRMHelper::EAutomatedTypeWallpaper);
+ iDrmHelper->RemoveAutomated( *iIdleWPContentUri2 );
+ delete iIdleWPContentUri2;
+ iIdleWPContentUri2 = NULL;
+ }
+ }
+
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::LoadTfxSrvPluginL
+// -----------------------------------------------------------------------------
+//
+TBool CAknsSrv::LoadTfxSrvPluginL()
+ {
+ // load ServerController
+ if (!iTFXServerCtrl)
+ {
+ TUid implementationUidCtrl = { KTfxSrvCtrlEcomImpl };
+ TAny* inputParams = &iWsSession;
+
+ iTFXServerCtrl =(MTransitionServerController*)
+ REComSession::CreateImplementationL( implementationUidCtrl,
+ iSrvControllerEComDtorUID,
+ inputParams );
+ }
+
+ // load Server
+ if (!iTFXServer)
+ {
+ TUid implementationUidSrv = { KTfxSrvEcomImpl };
+
+ iTFXServer =(MTransitionServer*)
+ REComSession::CreateImplementationL( implementationUidSrv,
+ iSrvEComDtorUID,
+ NULL );
+ }
+
+ if( iTFXServer && iTFXServerCtrl )
+ {
+ return ETrue;
+ }
+ return EFalse;
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::GetTransitionNameL
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::GetTransitionNameL( TFileName& aName, TAknsPkgID aPkgId )
+ {
+
+ User::LeaveIfError(iSknFile.FullName(aName));
+
+ TAknsPkgID pkgid = aPkgId;
+
+ aName = KTFxDefaultExtensionPath();
+ aName.AppendNumFixedWidthUC( pkgid.iNumber, EHex, 8 );
+ if( !pkgid.IsUid() )
+ {
+ aName.AppendNumFixedWidthUC( pkgid.iTimestamp, EHex, 8 );
+ }
+ aName.Append(KPathDelimiter);
+ aName.AppendNumFixedWidthUC( pkgid.iNumber, EHex, 8 );
+ if( !pkgid.IsUid() )
+ {
+ aName.AppendNumFixedWidthUC( pkgid.iTimestamp, EHex, 8 );
+ }
+ aName.Append(KTFxExtFileExt);
+ if (!AknsSrvUtils::IsFile( iFsSession, aName ) )
+ {
+ // Try the s60 default as a fallback
+ pkgid = KAknsPIDS60DefaultSkin;
+ aName = KTFxDefaultExtensionPath();
+ aName.AppendNumFixedWidthUC( pkgid.iNumber, EHex, 8 );
+ if( !pkgid.IsUid() )
+ {
+ aName.AppendNumFixedWidthUC( pkgid.iTimestamp, EHex, 8 );
+ }
+ aName.Append(KPathDelimiter);
+ aName.AppendNumFixedWidthUC( pkgid.iNumber, EHex, 8 );
+ if( !pkgid.IsUid() )
+ {
+ aName.AppendNumFixedWidthUC( pkgid.iTimestamp, EHex, 8 );
+ }
+
+ aName.Append(KTFxExtFileExt);
+ if (!AknsSrvUtils::IsFile( iFsSession, aName ) )
+ {
+ User::Leave(KErrNotFound);
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::CloseTfxServerConnection
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::CloseTfxServerConnection()
+ {
+ if( iTFXServer )
+ {
+ // disconnect also calls close to actual R-object
+ iTFXServer->Disconnect();
+ delete iTFXServer;
+ iTFXServer = NULL;
+ REComSession::DestroyedImplementation( iSrvEComDtorUID );
+ iSrvEComDtorUID.iUid = 0;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CAknsSrv::CheckAndCreateDRMHelper
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::CheckAndCreateDRMHelper()
+ {
+ if( iDrmHelper )
+ {
+ return;
+ }
+
+ AKNS_TRACE_INFO("CAknsSrv::CheckAndCreateDRMHelper No helper, creating");
+
+ TRAPD(helperErr, iDrmHelper = CDRMHelper::NewL() );
+ if( helperErr || (!iDrmHelper) )
+ {
+ AKNS_TRACE_ERROR("CAknsSrv::CheckAndCreateDRMHelper FATAL DRMHELPER FAILURE!");
+ User::Panic( KAknSkinSrvPanicCategory, EAknsSrvFatalDRMFailure );
+ }
+
+ AKNS_TRACE_INFO("CAknsSrv::CheckAndCreateDRMHelper COMPLETED");
+ }
+
+// -----------------------------------------------------------------------------
+// Sets default skin active.
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::SetDefaultSkinActive()
+ {
+ SetActiveSkinContent( iSettings->DefaultSkinPID() );
+ }
+
+// -----------------------------------------------------------------------------
+// Reads slide set image filenames from file to member variable.
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::ReadSlideSetImageFilesL()
+ {
+ WallpaperTimerL()->Stop();
+
+ TFileName fileName;
+ CAknsSrvDriveMaster::GetDefaultDrive(
+ DriveInfo::EDefaultPhoneMemory, fileName );
+ fileName.Append( KAknsSrvSSWPInifile );
+
+ RFile file;
+ User::LeaveIfError( file.Open(
+ iFsSession,fileName, EFileRead|EFileShareAny ));
+ CleanupClosePushL( file );
+
+ if ( iSlideSetNameArray )
+ {
+ iSlideSetNameArray->Reset();
+ delete iSlideSetNameArray;
+ iSlideSetNameArray = NULL;
+ }
+ iSlideSetNameArray = new(ELeave) CDesCArrayFlat(5);
+
+ TFileText textFile;
+ textFile.Set( file );
+ textFile.Seek( ESeekStart );
+
+ // Wait some time so that file write is finished.
+ User::After( KAknSkinSrvWaitForWriteToEnd );
+
+ FOREVER
+ {
+ TFileName filename;
+ if( textFile.Read( filename ) != KErrNone )
+ {
+ break;
+ }
+ iSlideSetNameArray->AppendL( filename );
+ }
+ iCurrentSlide = 0;
+ CleanupStack::PopAndDestroy(); // file
+ }
+
+
+// -----------------------------------------------------------------------------
+// Returns the pointer to slide set timer.
+// -----------------------------------------------------------------------------
+//
+CAknsSrvWallpaperTimer* CAknsSrv::WallpaperTimerL()
+ {
+ if ( iWallpaperTimer == NULL )
+ {
+ iWallpaperTimer = CAknsSrvWallpaperTimer::NewL( this );
+ }
+
+ return iWallpaperTimer;
+ }
+
+// -----------------------------------------------------------------------------
+// Sets slideset wallpaper interval timer active.
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::SetSlideSetTimerActiveL()
+ {
+ AKNS_TRACE_INFO("CAknsSrv::SetSlideSetTimerActiveL");
+
+ TInt timeout = iSettings->SlideSetWPTimeout();
+ WallpaperTimerL()->Start( timeout );
+ }
+
+
+// -----------------------------------------------------------------------------
+// Load max image size from CenRep.
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::InitMaxImageSizeL()
+ {
+ iMaxWallpaperSize = TSize(KAknsMaxWpWidth,KAknsMaxWpHeight);
+
+ CRepository* repository = CRepository::NewL( KCRUidWallpaperConfiguration );
+ repository->Get( KWpConfMaxWallpaperWidth, iMaxWallpaperSize.iWidth );
+ repository->Get( KWpConfMaxWallpaperHeight, iMaxWallpaperSize.iHeight );
+
+ delete repository;
+
+ }
+
+// -----------------------------------------------------------------------------
+// Backup current skin name and active default skin.
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::BackupAndActiveDefaultSkin()
+ {
+ if( iSkinOnRemovableDrive )
+ {
+ iOldSkin = iSettings->CachedSkinPID();
+ AKNS_TRACE_INFO("CAknsSrv::NotifyUSBAttach - USB attached, restoring default skin");
+ SetDefaultSkinActive();
+ RestoreDefaultSDSettings(ETrue);
+ MergeAndBroadcast();
+ }
+ else
+ {
+ // we really are not interested in mmc stuff if the current skin is not on MMC
+ iOldSkin = KAknsNullPkgID;
+ return;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// Reactive backup skin.
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::RestoreOldSkin()
+ {
+ if (iOldSkin != KAknsNullPkgID)
+ {
+
+ if ( iSettings->CachedSkinPID() != iSettings->DefaultSkinPID() )
+ {
+ //Keep None Default active skin
+ iOldSkin = KAknsNullPkgID;
+ return;
+ }
+
+ SetActiveSkinContent( iOldSkin );
+ iSettings->WriteSkinSettings(iOldSkin, ETrue);
+ iOldSkin = KAknsNullPkgID;
+ MergeAndBroadcast();
+ return; // if skin was on mmc, the wallpaper is handled aswell
+ }
+ // skin was not on mmc, but wp was
+ if ( iWPOnRemovableDrive && iWPFilename )
+ {
+ // Check if wallpaper file is still found.
+ // If so, continue observing.
+ if ( AknsSrvUtils::IsFile( iFsSession, *iWPFilename ) )
+ {
+ if (iWallpaperObserver)
+ {
+ iWallpaperObserver->IssueRequest();
+ }
+ }
+ else
+ {
+ iWPOnRemovableDrive = EFalse;
+ WallpaperLost();
+ }
+ }
+ }
+
+// ========================== OTHER EXPORTED FUNCTIONS =========================
+
+// -----------------------------------------------------------------------------
+// ThreadFunction()
+// Needed only in WINS build
+// -----------------------------------------------------------------------------
+//
+#ifdef __WINS__
+GLDEF_C TInt ThreadFunction( TAny* /*aThreadParams*/ )
+ {
+ // increase dll's user count so it can't get unloaded when the client
+ // application terminates
+
+ RLibrary lib;
+ lib.Load( KAknSkinSrvLibName ); // AknSkinServer.dll
+
+ return CAknsSrv::ThreadStart();
+ }
+#endif // __WINS__
+
+// -----------------------------------------------------------------------------
+// StartServer()
+// Create the server thread/process
+// -----------------------------------------------------------------------------
+//
+GLDEF_C TInt StartServer()
+ {
+ AKNS_TRACE_INFO("CAknsSrv/StartServer ENTERED");
+
+ TInt ret( KErrNone );
+
+ // Launch server process
+ RProcess server;
+ ret = server.Create( KAknSkinSrvExe, KNullDesC,
+ TUidType( KNullUid, KNullUid, KNullUid ),
+ EOwnerThread );
+
+ if( ret != KErrNone )
+ {
+ AKNS_TRACE_ERROR1("CAknsSrv/StartServer CREATE FAILED, ret=%d", ret);
+ return ret;
+ }
+
+ // Sync server startup
+ TRequestStatus rendezvousStatus;
+ server.Rendezvous(rendezvousStatus);
+
+ // Check the rendezvous status before resuming
+ if(rendezvousStatus!=KRequestPending)
+ {
+ AKNS_TRACE_INFO("CAknsSrv/StartServer: startup aborted");
+ server.Kill(0); // Abort startup
+ }
+ else
+ {
+ AKNS_TRACE_INFO("CAknsSrv/StartServer: resuming server process");
+ server.Resume(); // Resume process
+ }
+
+ AKNS_TRACE_INFO("CAknsSrv/StartServer: wait for server");
+
+ // Wait for server start (or death)
+ User::WaitForRequest(rendezvousStatus);
+
+ // We can't use status alone since it might be 0 in case of a panic
+ ret = (server.ExitType()==EExitPanic) ? KErrGeneral : rendezvousStatus.Int();
+
+ // Close server handle
+ server.Close();
+
+ AKNS_TRACE_INFO1("CAknsSrv/StartServer: server start status %d", rendezvousStatus.Int());
+
+ AKNS_TRACE_INFO("CAknsSrv/StartServer EXIT");
+
+ // Return the status code
+ return rendezvousStatus.Int();
+ }
+
+
+// -----------------------------------------------------------------------------
+// Check if the slideset wallpaper can change.
+// -----------------------------------------------------------------------------
+//
+TBool CAknsSrv::CanChangeSlidesetWallpaperL()
+ {
+ TBool retval = EFalse;
+ RWsSession wsSession;
+
+ TInt errorcode = wsSession.Connect();
+ if(errorcode != KErrNone)
+ {
+ return retval;
+ }
+
+ CleanupClosePushL(wsSession);
+ CApaWindowGroupName *topWindowgroup = CApaWindowGroupName::NewLC(wsSession, wsSession.GetFocusWindowGroup());
+ TUid topUid = topWindowgroup->AppUid();
+ CleanupStack::PopAndDestroy(2);
+
+ if( iSlidesetEnableAppUidArray.Find( topUid.iUid ) != KErrNotFound )
+ {
+ retval = ETrue;
+ }
+
+ return retval;
+ }
+
+// -----------------------------------------------------------------------------
+// Load slideset disable application uid from rss file.
+// -----------------------------------------------------------------------------
+//
+void CAknsSrv::InitSlidesetEnableAppUid()
+ {
+ for ( int i = 0; i < sizeof( KSlidesetEnableAppUid )
+ / sizeof( KSlidesetEnableAppUid[0] ); i++ )
+ {
+ iSlidesetEnableAppUidArray.Append( KSlidesetEnableAppUid[i] );
+ }
+ }
+
+// End of File