/*
* Copyright (c) 2002 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: Dynamic bitmap caching, SVG DOM tree precaching.
*
*/
// INCLUDE FILES
#include <e32std.h>
#include <fbs.h>
#include <barsread.h>
#include <barsc.h>
// Skin server client
#include <AknsSrvClient.h>
#include <akniconsrv.rsg>
#include <mifconvdefs.h>
#include <mifconvdefs.h>
#include "AknIconSrvCache.h"
#include "AknIconSrv.h"
#include "AknIconSrvIconItem.h"
#include "AknIconSrvPanic.h"
#include "AknIconSrvScheduler.h"
#include "AknIconTraces.h"
#ifdef PRECACHE2
#include "AknIconSrvPrecacher.h"
#endif
// CONSTANTS
// Contains cache configuration, non localized resource file.
_LIT( KAknIconResourceFile, "z:\\resource\\akniconsrv.rsc" );
#ifdef PRECACHE2
_LIT( KPrecacheThreadName2, "AknIconPrecache2" );
#endif
// ================= MEMBER FUNCTIONS ==========================================
CAknIconSrvCache::CAknIconSrvCache( CAknIconServer& aServer ) :
iDynamicallyCached( 8 ), iServer( aServer )
{
}
CAknIconSrvCache::~CAknIconSrvCache()
{
iDynamicallyCached.Close();
iPrecache.Close();
}
CAknIconSrvCache* CAknIconSrvCache::NewL( CAknIconServer& aServer )
{
CAknIconSrvCache* self = new( ELeave ) CAknIconSrvCache( aServer );
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop();
return self;
}
TDisplayMode MapConfigToDspMode(TInt aValue)
{
if ( aValue == 0 ) // value documented in the resource file
{
return EColor64K;
}
else if ( aValue == 2 ) // value documented in the resource file
{
return EColor16MU;
}
// Default to EColor16M, which is fastest to render alpha-blended.
else
{
return EColor16M;
}
}
TDisplayMode MapConfigToMaskMode(TInt aValue)
{
if ( aValue == 0 ) // value documented in the resource file
{
return EGray2;
}
// Default to EGray256
else
{
return EGray256;
}
}
TInt ReadConfigValue32L(const RResourceFile& aFile, TInt aResourceId)
{
TInt var;
TPckg<TInt> pack( var );
aFile.ReadL( pack, aResourceId );
return var;
}
#ifdef PRECACHE2
void DoPrecache2L( TAny* aParameters )
{
CAknIconSrvPrecacher* cacher = NULL;
cacher = CAknIconSrvPrecacher::NewL(*(static_cast<CAknIconServer*>( aParameters )) );
cacher->Start();
delete cacher;
}
GLDEF_C TInt PrecacheThreadFunction2( TAny* aParameters )
{
CTrapCleanup* cleanup = CTrapCleanup::New();
CActiveScheduler* scheduler = new CActiveScheduler;
if(!scheduler)
{
delete cleanup;
return KErrBadHandle;
}
CActiveScheduler::Install( scheduler );
TInt err = KErrNone;
TRAP(err,DoPrecache2L(aParameters));
delete scheduler;
delete cleanup;
return err;
}
#endif // PRECACHE2
void CAknIconSrvCache::ConstructL()
{
#ifdef PRECACHE2
User::LeaveIfError( iServer.iPreCacheThread.Create(
KPrecacheThreadName2,
PrecacheThreadFunction2,
0x2000, // stack size
NULL, // uses caller thread's heap
(TAny*)&iServer ) );
iServer.iPreCacheThread.SetPriority(KPreCache2Priority);
iServer.iPreCacheThread.Resume();
#endif // PRECACHE2
// Read resource file configuration.
RResourceFile file;
// Also prepare to the case that the resource file does not exist.
TRAPD( err, file.OpenL( iServer.FsSession(), KAknIconResourceFile ) );
if ( err == KErrNone )
{
CleanupClosePushL( file );
// Read bitmap compression config and set server variable.
TUint8 var1;
TPckg<TUint8> pack1( var1 );
file.ReadL( pack1, R_COMPRESS_BITMAPS );
iServer.iCompression = var1;
// read bitmap depth configs and set the server values
TInt value = ReadConfigValue32L(file, R_PREFERRED_ICON_DEPTH);
iServer.iIconMode = MapConfigToDspMode(value);
value = ReadConfigValue32L(file, R_PREFERRED_ICON_MASK_DEPTH);
iServer.iIconMaskMode = MapConfigToMaskMode(value);
value = ReadConfigValue32L(file, R_PREFERRED_PHOTO_DEPTH);
iServer.iPhotoMode = MapConfigToDspMode(value);
value = ReadConfigValue32L(file, R_PREFERRED_VIDEO_DEPTH);
iServer.iVideoMode = MapConfigToDspMode(value);
value = ReadConfigValue32L(file, R_PREFERRED_OFFSCREEN_DEPTH);
iServer.iOffscreenMode = MapConfigToDspMode(value);
value = ReadConfigValue32L(file, R_PREFERRED_OFFSCREEN_MASK_DEPTH);
iServer.iOffscreenMaskMode = MapConfigToMaskMode(value);
TPckg<TInt> pack3( iConfiguredMaxDynamicCacheSize );
file.ReadL( pack3, R_MAX_DYNAMIC_CACHE_SIZE );
EnableCache( ETrue );
CleanupStack::PopAndDestroy( 1); // file
}
// If no thread launched, complete request immediately.
TRequestStatus* status = &( iServer.ThreadLaunchStatus() );
User::RequestComplete( status, KErrNone );
}
// -----------------------------------------------------------------------------
// CAknIconSrvCache::CacheUnusedIcon
//
// Caches an icon (in bitmap form) that has just become unused.
// -----------------------------------------------------------------------------
//
TBool CAknIconSrvCache::CacheUnusedIcon( CAknIconSrvIconItem& aItem )
{
// If cache size is set to zero, return EFalse always.
#ifdef __AKNICON_TRACES
RDebug::Print( _L("AknIcon: %x CAknIconSrvCache::CacheUnusedIcon: iMaxDynamicCacheSize=%d"), this, iMaxDynamicCacheSize);
#endif
if ( !iMaxDynamicCacheSize )
{
return EFalse;
}
TBool ret = EFalse;
TInt lCacheSize = iDynamicCacheSize + iPrecacheSize ;
TInt iconDataSize = IconDataSize( aItem );
if ( iconDataSize <= iMaxDynamicCacheSize )
{
// If reached max size of the dynamic cache UpdateDynamicCacheSize.
if (lCacheSize + iconDataSize > iMaxDynamicCacheSize)
{
UpdateDynamicCacheSize();
}
// If reached max size of the dynamic cache,
// remove older cached items.
while ( iDynamicallyCached.Count() > 0 &&
lCacheSize + iconDataSize > iMaxDynamicCacheSize )
{
CAknIconSrvIconItem* oldest = iDynamicallyCached[0];
iDynamicCacheSize -= IconDataSize( *oldest );
iDynamicallyCached.Remove( 0 );
iServer.RemoveCachedItem( *oldest );
if (!iDynamicallyCached.Count())
{
#ifdef __AKNICON_TRACES
RDebug::Print( _L("AknIcon: %x CAknIconSrvCache::CacheUnusedIcon: reset iDynamicCacheSize=%d to 0"), this, iDynamicCacheSize);
#endif
iDynamicCacheSize = 0;
}
lCacheSize = iDynamicCacheSize + iPrecacheSize ;
}
// If dynamic cache is empty
// but precache size is greater than maxcachesize
// and Precache has some items
// and the new item to be added is a precache item
// delete the older precache items
if (iDynamicallyCached.Count() == 0)
{
while ( iPrecacheSize + iconDataSize > iMaxDynamicCacheSize
&& iPrecache.Count() > 0
&& aItem.iPrecacheItem)
{
CAknIconSrvIconItem* oldest = iPrecache[0];
iPrecacheSize -= IconDataSize( *oldest );
iPrecache.Remove( 0 );
iServer.RemoveCachedItem( *oldest );
if (!iPrecache.Count())
{
#ifdef __AKNICON_TRACES
RDebug::Print( _L("AknIcon: %x CAknIconSrvCache::CacheUnusedIcon: reset iDynamicCacheSize=%d to 0"), this, iPrecacheSize);
#endif
iPrecacheSize = 0;
}
}
}
// this check is needed for one case only
// if the cache is filled with precache items, dynamic cache is empty
// and a non precache item wants to be put in cache
// then dont put it
//Insert into dynamicCache or Precache
if(lCacheSize + iconDataSize <= iMaxDynamicCacheSize )
{
TInt lError;
if(aItem.iPrecacheItem)
{
lError = iPrecache.Append(&aItem);
}
else
{
lError = iDynamicallyCached.Append(&aItem);
}
// If no error encountered in insertion
// set icon as cached
if(lError == KErrNone)
{
aItem.SetCached();
if(aItem.iPrecacheItem)
{
iPrecacheSize += iconDataSize;
}
else
{
iDynamicCacheSize += iconDataSize;
}
ret = ETrue;
}
}
}
// If return ETrue, the server keeps the icon loaded even though the user
// count went to zero.
#ifdef __AKNICON_TRACES
RDebug::Print( _L("AknIcon: %x CAknIconSrvCache::CacheUnusedIcon: ret=%d"), this, ret);
#endif
return ret;
}
// -----------------------------------------------------------------------------
// CAknIconSrvCache::UpdateDynamicCacheSize
//
// Updates iDynamicCacheSize because its value could be deteriorated over time
// due to background bitmap compression.
// -----------------------------------------------------------------------------
//
void CAknIconSrvCache::UpdateDynamicCacheSize()
{
#ifdef __AKNICON_TRACES
RDebug::Print( _L("AknIcon: %x CAknIconSrvCache::UpdateDynamicCacheSize: old iDynamicCacheSize=%d, iServer.iCompression=%d"), this, iDynamicCacheSize, iServer.iCompression);
#endif
// Recalculate iDynamicCacheSize only if bitmap compression is enabled
if (iServer.iCompression)
{
iDynamicCacheSize = 0;
for(TInt i = 0; i < iDynamicallyCached.Count(); i++)
{
iDynamicCacheSize += IconDataSize(*iDynamicallyCached[i]);
}
}
#ifdef __AKNICON_TRACES
RDebug::Print( _L("AknIcon: %x CAknIconSrvCache::UpdateDynamicCacheSize: new iDynamicCacheSize=%d"), this, iDynamicCacheSize);
#endif
}
// -----------------------------------------------------------------------------
// CAknIconSrvCache::RemoveIfCached
// -----------------------------------------------------------------------------
//
void CAknIconSrvCache::RemoveIfCached( CAknIconSrvIconItem& aItem )
{
if ( aItem.IsCached() )
{
// search for item in iDynamicallyCached & iPrecache
TInt lDynamicIndex = iDynamicallyCached.Find( &aItem );
TInt lPrecacheIndex = iPrecache.Find(&aItem);
__ASSERT_DEBUG( lDynamicIndex >= 0 || lPrecacheIndex >= 0,
User::Panic( KAknIconSrvPanicCategory, ESrvPanicCacheCorrupt ) );
if(lDynamicIndex >= 0)
{
iDynamicallyCached.Remove( lDynamicIndex );
iDynamicCacheSize -= IconDataSize( aItem );
}
else if(lPrecacheIndex >= 0)
{
iPrecache.Remove(lPrecacheIndex);
iPrecacheSize -= IconDataSize(aItem);
}
aItem.ClearCached();
}
}
// -----------------------------------------------------------------------------
// CAknIconSrvCache::DynamicToPrecache
// -----------------------------------------------------------------------------
//
void CAknIconSrvCache::DynamicToPrecache( CAknIconSrvIconItem& aItem )
{
if ( aItem.IsCached() )
{
// search for item in iDynamicallyCached
TInt lDynamicIndex = iDynamicallyCached.Find( &aItem );
if(lDynamicIndex >= 0)
{
CAknIconSrvIconItem* moveItem = iDynamicallyCached[lDynamicIndex];
if (iPrecache.Append(moveItem) == KErrNone)
{
iPrecacheSize += IconDataSize(aItem);
iDynamicallyCached.Remove( lDynamicIndex );
iDynamicCacheSize -= IconDataSize( aItem );
}
}
}
}
// -----------------------------------------------------------------------------
// CAknIconSrvCache::ResetDynamicCache
// -----------------------------------------------------------------------------
//
void CAknIconSrvCache::ResetDynamicCache()
{
#ifdef _DEBUG
EnableCache( EFalse );
#endif // _DEBUG
}
// -----------------------------------------------------------------------------
// CAknIconSrvCache::IconDataSize
// -----------------------------------------------------------------------------
//
TInt CAknIconSrvCache::IconDataSize( CAknIconSrvIconItem& aItem )
{
TInt byteSize = aItem.iBitmap->Header().iBitmapSize;
if ( aItem.iMask )
{
byteSize += aItem.iMask->Header().iBitmapSize;
}
return byteSize;
}
// -----------------------------------------------------------------------------
// CAknIconSrvCache::EnableCache
// -----------------------------------------------------------------------------
//
void CAknIconSrvCache::EnableCache( TBool aEnable )
{
if ( aEnable )
{
// enable the cache by setting the configured max cache size.
iMaxDynamicCacheSize = iConfiguredMaxDynamicCacheSize;
}
else
{
// disable the cache by removing all dynamically cached
// icons and setting the max cache size to zero, which will
// prevent further icons from being added.
while ( iDynamicallyCached.Count() )
{
CAknIconSrvIconItem* item = iDynamicallyCached[0];
iDynamicallyCached.Remove( 0 );
iServer.RemoveCachedItem( *item );
}
iDynamicCacheSize = 0;
while(iPrecache.Count())
{
CAknIconSrvIconItem* item = iPrecache[0];
iPrecache.Remove( 0 );
iServer.RemoveCachedItem( *item );
}
iPrecacheSize = 0;
iMaxDynamicCacheSize = 0;
}
}
// End of File