diff -r 000000000000 -r 05e9090e2422 skins/AknSkins/srvsrc/AknsSrv.cpp --- /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 +#include +#include +#include +#include +#include +#include +#include +#include "tfxconfigparser.h" +#include +#include + + +#include "AknsSrvSettings.h" +#include "AknsSrvScheduler.h" +#include "AknsSkinContent.h" +#include +#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 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(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 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 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(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 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 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