/*
* Copyright (c) 2009 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:
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <AknsSrvChunkLookup.h>
#include <AknsConstants.h>
#include <AknsItemDef.h>
#include "bganimhost.h"
#include <platform/ssm/startupdomainpskeys.h>
typedef void* (*plugingetinterfacefunc)(int);
const TInt KRefreshTarget = 99;
_LIT(KExeCaption,"BG anim host");
static const TUint KMaxGPUMemUsage = 1024*1024*4;
CBgAnimHost::CBgAnimHost():iIsUIReady(EFalse)
{
}
CBgAnimHost::~CBgAnimHost()
{
iSkinSrv.Close();
delete iCurrentPluginDllName;
delete iCurrentPluginAssetDir;
delete iTimer;
delete iTheReaper;
delete iDoomBringer;
ReleasePlugin();
#if !defined(SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS)
delete iSCPropertyListener;
#endif
delete iHSFgStatusPropertyListener;
delete iThemeRepositoryListener;
iSensorListeners.Close();
delete CActiveScheduler::Current();
CActiveScheduler::Install(NULL);
ReleaseWindowSurface();
ReleaseEGL();
DestroyWindow();
}
void CBgAnimHost::ConstructL()
{
User::LeaveIfError(iWsSession.Connect());
TUid wgUid;
wgUid.iUid = 0x200286D3;
TInt id = 0;
CApaWindowGroupName::FindByAppUid(wgUid, iWsSession, id);
if (id != KErrNotFound)
{
User::Leave(KErrAlreadyExists);
}
iWsSession.ComputeMode(RWsSession::EPriorityControlDisabled);
iWsSession.EnableWindowSizeCacheL();
CActiveScheduler *ac = new (ELeave) CActiveScheduler;
CActiveScheduler::Install(ac);
iTimer = CHighResTimer::NewL(TCallBack(TimerFunc, this),CActive::EPriorityStandard);
iTheReaper = CHighResTimer::NewL(TCallBack(ReaperFunc, this),CActive::EPriorityStandard);
iThemeRepositoryListener = CThemeRepositoryListener::NewL(&iRunning);
#if !defined(SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS)
iSCPropertyListener = CScreenSaverPropertyListener::NewL(TCallBack(ScreenSaverCallback, this));
#endif
iHSFgStatusPropertyListener = CFGAppPropertyListener::NewL(TCallBack(FgAppCallback, this));
CreateWindowL();
User::LeaveIfError(iSkinSrv.Connect());
// load the initial plugin
GetPluginConfigurationL();
LoadPluginL();
InitEGLL();
CreateWindowSurfaceL();
User::LeaveIfError(iPlugin->gpuresourcesavailable(1));
iThemeRepositoryListener->IssueRequest();
#if !defined(SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS)
iSCPropertyListener->IssueRequest();
#endif
iHSFgStatusPropertyListener->IssueRequest();
}
void CBgAnimHost::CreateWindowL()
{
iScreenDevice = new (ELeave) CWsScreenDevice(iWsSession);
User::LeaveIfError(iScreenDevice->Construct(0));
TPixelsAndRotation rot;
TInt screenmode = iScreenDevice->CurrentScreenMode();
iScreenDevice->GetScreenModeSizeAndRotation(screenmode, rot);
if (rot.iRotation == CFbsBitGc::EGraphicsOrientationNormal)
{
iDisplaySize = rot.iPixelSize;
}
else
{
iDisplaySize.iWidth = rot.iPixelSize.iHeight;
iDisplaySize.iHeight = rot.iPixelSize.iWidth;
}
iRealDisplaySize = iDisplaySize;
iDisplaySize.iWidth/=2;
iDisplaySize.iHeight/=2;
iWindowGroup=RWindowGroup(iWsSession);
User::LeaveIfError(iWindowGroup.Construct((TUint32)&iWindowGroup));
iWindowGroup.SetOrdinalPosition(-1,-1000);
iWindow=RWindow(iWsSession);
User::LeaveIfError(iWindow.Construct(iWindowGroup, (TUint32)&iWindow));
User::LeaveIfError(iWindow.SetExtentErr(TPoint(0,0),iDisplaySize));
iWindow.SetVisible(ETrue);
iWindow.Activate();
iWindGroupName = CApaWindowGroupName::NewL(iWsSession, iWindowGroup.Identifier());
TUid wgUid;
wgUid.iUid = 0x200286D3;
iWindGroupName->SetAppUid(wgUid);
iWindGroupName->SetCaptionL(KExeCaption);
iWindGroupName->SetHidden(ETrue);
iWindGroupName->SetAppReady(ETrue);
iWindGroupName->SetSystem(ETrue);
iWindGroupName->SetWindowGroupName(iWindowGroup);
iWsSession.Flush();
}
void CBgAnimHost::DestroyWindow()
{
delete iWindGroupName;
iWindow.Close();
iWindowGroup.Close();
delete iScreenDevice;
iWsSession.Close();
}
void CBgAnimHost::InitEGLL()
{
iEGLDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
TInt minorVersion;
TInt majorVersion;
if (!iEGLDisplay)
{
User::Leave(KErrHardwareNotAvailable);
}
if( !eglInitialize( iEGLDisplay, &majorVersion, &minorVersion ) )
{
User::Leave(KErrHardwareNotAvailable);
}
iEGLInitialized = ETrue;
}
void CBgAnimHost::ReleaseEGL()
{
if (iEGLInitialized)
{
eglTerminate( iEGLDisplay );
iEGLInitialized = EFalse;
}
}
void CBgAnimHost::ReleaseWindowSurface(TBool aReleaseObserver)
{
if (iEGLInitialized && iSurfaceInitialized)
{
eglDestroyContext( iEGLDisplay, iEGLContext );
eglDestroySurface( iEGLDisplay, iEGLSurface );
eglMakeCurrent( iEGLDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT );
iWsSession.Flush();
iSurfaceInitialized = EFalse;
if (aReleaseObserver && iCompSource)
{
iCompSource->RemoveObserver(*this);
delete iCompSource;
iCompSource = NULL;
}
}
}
const EGLint openvg_surface_attrs[] =
{
EGL_VG_ALPHA_FORMAT, EGL_VG_ALPHA_FORMAT_PRE,
EGL_NONE
};
const EGLint opengl_es2_context_attrs[] =
{
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
void CBgAnimHost::CreateWindowSurfaceL()
{
const EGLint* conf = iPlugin->getpreferredconfig();
TInt numItems = 1;
while (conf[numItems-1] != EGL_NONE)
{
numItems++;
}
EGLint* preferredConfig = (EGLint*)malloc(sizeof(EGLint)*numItems);
for (TInt count = 0; count < numItems;count++)
{
EGLint val = conf[count];
preferredConfig[count] = val;
switch (val)
{
case EGL_BUFFER_SIZE:
if (conf[count+1] != 16)
{
preferredConfig[count+1] = 16;
count++;
}
break;
case EGL_ALPHA_SIZE:
if (conf[count+1] != 0)
{
preferredConfig[count+1] = 0;
count++;
}
break;
case EGL_RED_SIZE:
if (conf[count+1] != 5)
{
preferredConfig[count+1] = 5;
count++;
}
break;
case EGL_GREEN_SIZE:
if (conf[count+1] != 6)
{
preferredConfig[count+1] = 6;
count++;
}
break;
case EGL_BLUE_SIZE:
if (conf[count+1] != 5)
{
preferredConfig[count+1] = 5;
count++;
}
break;
default:
break;
}
}
TInt index = 0;
// figure out what API was requested
EGLint api = EGL_NONE;
while (conf[index] != EGL_NONE)
{
if (conf[index] == EGL_RENDERABLE_TYPE)
{
if (conf[index+1]&EGL_OPENVG_BIT)
{
api = EGL_OPENVG_BIT;
if (!eglBindAPI(EGL_OPENVG_API))
{
User::Leave(KErrAbort);
}
}
else if ( (conf[index+1]&EGL_OPENGL_ES_BIT) ||
(conf[index+1]&EGL_OPENGL_ES2_BIT) )
{
api = conf[index+1];
if (!eglBindAPI(EGL_OPENGL_ES_API))
{
User::Leave(KErrAbort);
}
}
index++;
}
index++;
}
EGLConfig *configList = NULL;
EGLint numConfigs = 0;
EGLint configSize = 0;
// Get the number of possible EGLConfigs
if ( !eglGetConfigs( iEGLDisplay, configList, configSize, &numConfigs ) )
{
User::Leave(KErrAbort);
}
configSize = numConfigs;
configList = (EGLConfig*)malloc(sizeof(EGLConfig)*configSize);
if (!configList)
{
User::Leave(KErrNoMemory);
}
if( !eglChooseConfig( iEGLDisplay, preferredConfig, configList, configSize, &numConfigs ) )
{
User::Leave(KErrAbort);
}
TInt confIndex = 0;
// we should now have a list of configs matching our preferred attributes
for (TInt count = 0;count<numConfigs;count++)
{
EGLint buffer_size;
EGLint red_size;
EGLint green_size;
EGLint blue_size;
EGLint alpha_size;
eglGetConfigAttrib(iEGLDisplay, configList[count],EGL_BUFFER_SIZE,&buffer_size);
eglGetConfigAttrib(iEGLDisplay, configList[count],EGL_RED_SIZE,&red_size);
eglGetConfigAttrib(iEGLDisplay, configList[count],EGL_GREEN_SIZE,&green_size);
eglGetConfigAttrib(iEGLDisplay, configList[count],EGL_BLUE_SIZE,&blue_size);
eglGetConfigAttrib(iEGLDisplay, configList[count],EGL_ALPHA_SIZE,&alpha_size);
if (buffer_size == 16 && red_size == 5 && green_size == 6 && blue_size == 5 && alpha_size == 0)
{
confIndex = count;
break;
}
}
EGLint* context_attrs = NULL;
if (api == EGL_OPENGL_ES2_BIT)
{
context_attrs = (EGLint*)opengl_es2_context_attrs;
}
iEGLContext = eglCreateContext( iEGLDisplay, configList[confIndex], NULL, context_attrs );
if( !iEGLContext )
{
User::Leave(KErrAbort);
}
EGLint* surface_attrs = NULL;
#if !defined(__WINS__) // no pre multiplied surfaces on wins (yet)
if (api == EGL_OPENVG_BIT)
{
surface_attrs = (EGLint*)openvg_surface_attrs;
}
#endif
iEGLSurface = eglCreateWindowSurface( iEGLDisplay, configList[confIndex], &iWindow, surface_attrs );
if( !iEGLSurface )
{
User::Leave(KErrAbort);
}
eglMakeCurrent( iEGLDisplay, iEGLSurface, iEGLSurface, iEGLContext );
free(configList);
free(preferredConfig);
FOREVER
{
TRAPD(cerr, iCompSource = CAlfCompositionSource::NewL(iWindow));
if (!cerr)
{
iCompSource->AddCompositionObserverL(*this);
iCompSource->SetIsBackgroundAnim(ETrue);
iCompSource->SetExtent(TRect(TPoint(0,0),iRealDisplaySize),0);
break;
}
else
{
User::After(1000000);
}
}
iSurfaceInitialized = ETrue;
}
TBool CBgAnimHost::GetPluginConfigurationL()
{
// dig out the skin config from skin server
HBufC* configstr = NULL;
CAknsSrvChunkLookup* cl = iSkinSrv.CreateChunkLookupL();
CleanupStack::PushL(cl);
CAknsStringItemDef* configitem = static_cast<CAknsStringItemDef*>(cl->LookupAndCreateDefL( KAknsIIDPropertyAnimBgParam ));
User::LeaveIfNull(configitem);
CleanupStack::PushL(configitem);
configstr = configitem->String().AllocL();
CleanupStack::PopAndDestroy(2); // cl, configitem
CleanupStack::PushL(configstr);
TLex lex(*configstr);
HBufC* dllname = lex.NextToken().AllocL();
CleanupStack::PushL(dllname);
if (!dllname || !dllname->Length())
{
User::Leave(KErrNotFound);
}
HBufC* assetdir = lex.NextToken().AllocL();
CleanupStack::PushL(assetdir);
if (!assetdir || !assetdir->Length())
{
User::Leave(KErrNotFound);
}
TBool confchanged = EFalse;
if (!iCurrentPluginDllName || !iCurrentPluginAssetDir ||
(iCurrentPluginDllName && !iCurrentPluginDllName->CompareF(*dllname)) ||
(iCurrentPluginAssetDir && !iCurrentPluginAssetDir->CompareF(*assetdir)) )
{
confchanged = ETrue;
delete iCurrentPluginDllName;
delete iCurrentPluginAssetDir;
iCurrentPluginDllName = dllname;
iCurrentPluginAssetDir = assetdir;
CleanupStack::Pop(2); // dllname, assetdir
}
else
{
CleanupStack::PopAndDestroy(2); // dllname, assetdir
}
CleanupStack::PopAndDestroy(); // configstr
return confchanged;
}
void CBgAnimHost::LoadPluginL()
{
User::LeaveIfError(iPluginLibrary.Load(*iCurrentPluginDllName));
plugingetinterfacefunc getif = (plugingetinterfacefunc)iPluginLibrary.Lookup(1);
if (!getif)
{
iPluginLibrary.Close();
User::Leave(KErrNotFound);
}
iPlugin = (plugin_export_v1_t*) getif(1);
TBuf8<256> pluginpath;
pluginpath.Copy(*iCurrentPluginAssetDir);
User::LeaveIfError(iPlugin->initialize((const char*)pluginpath.PtrZ(), KMaxGPUMemUsage));
iPlugin->setdisplaydimensions(iDisplaySize.iWidth, iDisplaySize.iHeight);
if (iPlugin->desiredsensors && iPlugin->receivesensordata)
{
const unsigned int* sensors = iPlugin->desiredsensors();
while (*sensors)
{
CSensorListener* listener = NULL;
TRAPD(serr, listener = CSensorListener::NewL(this, *sensors++));
if (!serr)
{
iSensorListeners.Append(listener);
StartSensorsL();
}
}
}
}
void CBgAnimHost::ReleasePlugin()
{
if (iPlugin)
{
while (iSensorListeners.Count())
{
delete iSensorListeners[0];
iSensorListeners.Remove(0);
}
iPlugin->gpuresourcesavailable(0);
iPlugin->destroy();
free(iPlugin);
iPlugin = NULL;
iPluginLibrary.Close();
}
}
void CBgAnimHost::NewFrame()
{
if (!iRunning && !iDoomBringer)
{
iDoomBringer = CHighResTimer::NewL(TCallBack(DoomBringerFunc, this),CActive::EPriorityStandard);
iDoomBringer->CallBack(5000);
}
if (iRunning && iDoomBringer)
{
delete iDoomBringer;
iDoomBringer = NULL;
}
if (!iSurfaceInitialized)
{
return;
}
if (!iIsUIReady)
{
TInt lValOfNoUse;
TInt err = RProperty::Get( KPSUidStartup,
KPSStartupUiPhase,
lValOfNoUse);
if (err == KErrNotFound)
{
iTimer->CallBack(500);
return;
}
}
iIsUIReady = ETrue;
TTime start;
start.UniversalTime();
iPlugin->produceframe();
eglSwapBuffers(iEGLDisplay, iEGLSurface);
TTime end;
end.UniversalTime();
TInt64 elapsed = end.MicroSecondsFrom(start).Int64();
elapsed/=1000; // convert to milliseconds
TInt nextcallback = KRefreshTarget-(TInt)elapsed;
if (nextcallback < 1)
nextcallback = 1;
iTimer->CallBack(nextcallback);
}
void CBgAnimHost::Kill()
{
if (!iRunning)
{
CActiveScheduler::Stop();
}
else
{
delete iDoomBringer;
iDoomBringer = NULL;
}
return;
}
TInt CBgAnimHost::DoomBringerFunc(TAny* aPtr)
{
CBgAnimHost* me = (CBgAnimHost*)(aPtr);
me->Kill();
return ETrue;
}
TInt CBgAnimHost::TimerFunc(TAny* aPtr)
{
CBgAnimHost* me = (CBgAnimHost*)(aPtr);
me->NewFrame();
return ETrue;
}
TInt CBgAnimHost::ReaperFunc(TAny* aPtr)
{
CBgAnimHost* me = (CBgAnimHost*)(aPtr);
me->CompositionTargetHidden();
return ETrue;
}
void CBgAnimHost::ExecuteL()
{
// finally start our timer and scheduler...
iTimer->CallBack(100);
iTimerRunning = ETrue;
iRunning = ETrue;
// we only want to receive skin change messages
// after we have been properly initialized
// and running, close the session without observer
// and re-open with observer
iSkinSrv.Close();
User::LeaveIfError(iSkinSrv.Connect(this));
CActiveScheduler::Start();
}
void CBgAnimHost::FrameReady(TInt /*aScreenNumber*/)
{
}
void CBgAnimHost::RunningLowOnGraphicsMemory()
{
/* iThemeRepositoryListener->GPuMemLow(ETrue);
CompositionTargetHidden();*/
}
void CBgAnimHost::GraphicsMemoryGood()
{
/* CompositionTargetVisible();
iThemeRepositoryListener->GPuMemLow(EFalse);*/
}
void CBgAnimHost::CompositionTargetHidden()
{
if (!iSurfaceInitialized)
{
// don't bother if we are already in
// a correct state..
return;
}
// release gpu resources...
iTimer->Cancel();
iTimerRunning = EFalse;
iPlugin->gpuresourcesavailable(0);
ReleaseWindowSurface(EFalse);
StopSensors();
}
void CBgAnimHost::CompositionTargetVisible()
{
if (!iRunning && !iDoomBringer)
{
iDoomBringer = CHighResTimer::NewL(TCallBack(DoomBringerFunc, this),CActive::EPriorityStandard);
iDoomBringer->CallBack(5000);
}
if (iSurfaceInitialized || iHiddenDueSC || iReaped)
{
// don't bother if we are already in
// a correct state, or if we are hidden by
// the screensaver
return;
}
if (!iSurfaceInitialized && iCompSource)
{
iCompSource->RemoveObserver(*this);
delete iCompSource;
iCompSource = NULL;
}
TRAPD(err,CreateWindowSurfaceL());
// reclaim gpu resources
if (!err)
{
iPlugin->gpuresourcesavailable(1);
iPlugin->setfaded(iHSFgStatusPropertyListener->GetHSFGStatus());
iTimer->CallBack(1);
iTimerRunning = ETrue;
}
TRAP_IGNORE(StartSensorsL());
}
void CBgAnimHost::HandleScreenSaverEvent()
{
#if !defined(SYMBIAN_GRAPHICS_WSERV_QT_EFFECTS)
TInt scStatus = iSCPropertyListener->GetScreenSaverStatus();
if (scStatus)
{
// screensaver is ON
iHiddenDueSC = ETrue;
CompositionTargetHidden();
}
else
{
// screensaver is OFF
iHiddenDueSC = EFalse;
CompositionTargetVisible();
}
#endif
}
void CBgAnimHost::StartSensorsL()
{
for (TInt count = 0; count < iSensorListeners.Count(); count++)
{
iSensorListeners[count]->StartListeningL();
}
}
void CBgAnimHost::StopSensors()
{
for (TInt count = 0; count < iSensorListeners.Count(); count++)
{
iSensorListeners[count]->StopListening();
}
}
void CBgAnimHost::HandleFGAppEvent()
{
if (!iRunning && !iDoomBringer)
{
iDoomBringer = CHighResTimer::NewL(TCallBack(DoomBringerFunc, this),CActive::EPriorityStandard);
iDoomBringer->CallBack(5000);
}
if (iPlugin && iPlugin->setfaded)
{
iPlugin->setfaded(iHSFgStatusPropertyListener->GetHSFGStatus());
if (!iHSFgStatusPropertyListener->GetHSFGStatus())
{
// reap the anim in 5 seconds...
// 5 seconds is probably just allright
// to have enought time for the plugin to fade out...
iReaped = ETrue;
iTheReaper->CallBack(5000);
}
else
{
iReaped = EFalse;
iTheReaper->Cancel();
CompositionTargetVisible();
}
}
}
TInt CBgAnimHost::ScreenSaverCallback(TAny* aPtr)
{
CBgAnimHost* me = (CBgAnimHost*) aPtr;
me->HandleScreenSaverEvent();
return EFalse;
}
TInt CBgAnimHost::FgAppCallback(TAny* aPtr)
{
CBgAnimHost* me = (CBgAnimHost*) aPtr;
me->HandleFGAppEvent();
return EFalse;
}
void CBgAnimHost::DataReceived( CSensrvChannel& aChannel, TInt aCount, TInt aDataLost )
{
if (iPlugin && iPlugin->receivesensordata)
{
iPlugin->receivesensordata((void*)&aChannel, aCount, aDataLost);
}
}
void CBgAnimHost::DataError( CSensrvChannel& aChannel, TSensrvErrorSeverity aError )
{
}
void CBgAnimHost::GetDataListenerInterfaceL( TUid aInterfaceUid, TAny*& aInterface)
{
}
void CBgAnimHost::SkinContentChanged()
{
}
void CBgAnimHost::SkinConfigurationChanged( const TAknsSkinStatusConfigurationChangeReason aReason )
{
if (aReason == EAknsSkinStatusConfigurationDeployed && iPlugin)
{
// okay, the skin has changed, let's check that should we load a different
// animation plugin
TBool changed = EFalse;
TRAPD(err, changed = GetPluginConfigurationL());
if (err || !changed)
{
// plugin configuration has not changed, or there is not animation
// in the theme, just return
return;
}
CompositionTargetHidden();
ReleasePlugin();
TRAP_IGNORE(LoadPluginL());
CompositionTargetVisible();
}
}
void CBgAnimHost::SkinPackageChanged( const TAknsSkinStatusPackageChangeReason /*aReason*/ )
{
}