1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 #include <stdio.h>

    18 #include <stdlib.h>

    19 #include <AknsSrvClient.h>

    20 #include <AknsSrvChunkLookup.h>

    21 #include <AknsConstants.h>

    22 #include <AknsItemDef.h>

    23 

    24 #include "bganimhost.h"

    25 

    26 

    27 typedef void* (*plugingetinterfacefunc)(int);

    28 

    29 const TInt KRefreshTarget = 15;

    30 _LIT(KExeCaption,"BG anim host");

    31 

    32 static const TUint KMaxGPUMemUsage = 1024*1024*4;

    33 

    34 

    35 CBgAnimHost::CBgAnimHost() 

    36     {

    37     }

    38     

    39 CBgAnimHost::~CBgAnimHost() 

    40     {

    41     delete iTimer;

    42     if (iPlugin)

    43         {

    44         iPlugin->destroy();

    45         free(iPlugin);

    46         }

    47     iPluginLibrary.Close();

    48     delete iSCPropertyListener;

    49     delete iThemeRepositoryListener;

    50     while (iSensorListeners.Count())

    51         {

    52         delete iSensorListeners[0];

    53         iSensorListeners.Remove(0);

    54         }

    55     iSensorListeners.Close();

    56     delete CActiveScheduler::Current();

    57     CActiveScheduler::Install(NULL);

    58     ReleaseWindowSurface();

    59     ReleaseEGL();

    60     DestroyWindow();

    61     }

    62 

    63 void CBgAnimHost::ConstructL() 

    64     {

    65     User::LeaveIfError(iWsSession.Connect());

    66     TUid wgUid;

    67     wgUid.iUid = 0x200286D3;

    68     TInt id = 0;

    69     CApaWindowGroupName::FindByAppUid(wgUid, iWsSession, id);

    70     if (id != KErrNotFound)

    71         {

    72         User::Leave(KErrAlreadyExists);

    73         }

    74 

    75     iWsSession.ComputeMode(RWsSession::EPriorityControlDisabled);

    76     iWsSession.EnableWindowSizeCacheL();

    77         

    78     CActiveScheduler *ac = new (ELeave) CActiveScheduler;

    79     CActiveScheduler::Install(ac);

    80     iTimer = CHighResTimer::NewL(TCallBack(TimerFunc, this),CActive::EPriorityStandard);

    81     iThemeRepositoryListener = CThemeRepositoryListener::NewL(&iRunning);

    82     iSCPropertyListener = CScreenSaverPropertyListener::NewL(TCallBack(ScreenSaverCallback, this));

    83     

    84     CreateWindowL();

    85 

    86     // load the initial plugin

    87     LoadPluginL();

    88     InitEGLL();

    89     CreateWindowSurfaceL();

    90     

    91     User::LeaveIfError(iPlugin->gpuresourcesavailable(1));

    92     iThemeRepositoryListener->IssueRequest();

    93     iSCPropertyListener->IssueRequest();

    94     }

    95     

    96 void CBgAnimHost::CreateWindowL()

    97     {

    98     iScreenDevice = new (ELeave) CWsScreenDevice(iWsSession);

    99     User::LeaveIfError(iScreenDevice->Construct(0));

   100     

   101     TPixelsAndRotation rot;

   102     TInt screenmode = iScreenDevice->CurrentScreenMode(); 

   103     iScreenDevice->GetScreenModeSizeAndRotation(screenmode, rot);

   104     if (rot.iRotation == CFbsBitGc::EGraphicsOrientationNormal)

   105         {

   106         iDisplaySize = rot.iPixelSize;

   107         }

   108     else

   109         {

   110         iDisplaySize.iWidth = rot.iPixelSize.iHeight;

   111         iDisplaySize.iHeight = rot.iPixelSize.iWidth;

   112         }

   113     

   114     iRealDisplaySize = iDisplaySize;

   115     iDisplaySize.iWidth/=2;

   116     iDisplaySize.iHeight/=2;

   117     

   118     iWindowGroup=RWindowGroup(iWsSession);

   119     User::LeaveIfError(iWindowGroup.Construct((TUint32)&iWindowGroup));

   120 	iWindowGroup.SetOrdinalPosition(-1,-1000);

   121 	

   122 	iWindow=RWindow(iWsSession);

   123 	User::LeaveIfError(iWindow.Construct(iWindowGroup, (TUint32)&iWindow));

   124 	User::LeaveIfError(iWindow.SetExtentErr(TPoint(0,0),iDisplaySize));

   125     iWindow.SetVisible(ETrue);

   126 	iWindow.Activate();

   127 

   128     iWindGroupName = CApaWindowGroupName::NewL(iWsSession, iWindowGroup.Identifier());

   129 

   130     TUid wgUid;

   131     wgUid.iUid = 0x200286D3;

   132     

   133     iWindGroupName->SetAppUid(wgUid);

   134     iWindGroupName->SetCaptionL(KExeCaption);

   135     iWindGroupName->SetHidden(ETrue);

   136     iWindGroupName->SetAppReady(ETrue);

   137     iWindGroupName->SetSystem(ETrue);

   138     iWindGroupName->SetWindowGroupName(iWindowGroup);

   139 

   140 	iWsSession.Flush();

   141     }

   142     

   143 void CBgAnimHost::DestroyWindow()

   144     {

   145     delete iWindGroupName;

   146     iWindow.Close();

   147     iWindowGroup.Close();

   148     delete iScreenDevice;

   149     iWsSession.Close();

   150     }

   151     

   152 void CBgAnimHost::InitEGLL()

   153     {

   154     iEGLDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);

   155     TInt minorVersion;

   156     TInt majorVersion;

   157     if (!iEGLDisplay)

   158         {

   159         User::Leave(KErrHardwareNotAvailable);

   160         }

   161   	if( !eglInitialize( iEGLDisplay, &majorVersion, &minorVersion ) ) 

   162   	    {

   163         User::Leave(KErrHardwareNotAvailable);

   164   	    }

   165   	iEGLInitialized = ETrue;

   166     }

   167 

   168 void CBgAnimHost::ReleaseEGL()

   169     {

   170     if (iEGLInitialized)

   171         {

   172         eglTerminate( iEGLDisplay );   

   173         iEGLInitialized = EFalse;

   174         }

   175     }

   176     

   177 void CBgAnimHost::ReleaseWindowSurface(TBool aReleaseObserver)

   178     {

   179     if (iEGLInitialized && iSurfaceInitialized)

   180         {

   181         eglDestroyContext( iEGLDisplay, iEGLContext );

   182         eglDestroySurface( iEGLDisplay, iEGLSurface );

   183         eglMakeCurrent( iEGLDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT );

   184         iWsSession.Flush();

   185         

   186         iSurfaceInitialized = EFalse;

   187         

   188         if (aReleaseObserver)

   189             {

   190             iCompSource->RemoveObserver(*this);

   191             delete iCompSource;

   192             iCompSource = NULL;

   193             }

   194         }

   195     }

   196 

   197 const EGLint openvg_surface_attrs[] = 

   198         { 

   199         EGL_VG_ALPHA_FORMAT, EGL_VG_ALPHA_FORMAT_PRE,

   200         EGL_NONE

   201         };

   202 

   203 const EGLint opengl_es2_context_attrs[] = 

   204         {

   205         EGL_CONTEXT_CLIENT_VERSION, 2,

   206         EGL_NONE

   207         };

   208 

   209     

   210 void CBgAnimHost::CreateWindowSurfaceL()

   211     {

   212     const EGLint* conf = iPlugin->getpreferredconfig();

   213    

   214     TInt numItems = 1;

   215     while (conf[numItems-1] != EGL_NONE)

   216         {

   217         numItems++;

   218         }

   219 

   220     EGLint* preferredConfig = (EGLint*)malloc(sizeof(EGLint)*numItems);

   221     for (TInt count = 0; count < numItems;count++)

   222         {

   223         EGLint val = conf[count];

   224         preferredConfig[count] = val;

   225         switch (val)

   226             {

   227             case EGL_BUFFER_SIZE:

   228                 if (conf[count+1] != 16)

   229                     {

   230                     preferredConfig[count+1] = 16;

   231                     count++;

   232                     }

   233                 break;

   234             case EGL_ALPHA_SIZE:

   235                 if (conf[count+1] != 0)

   236                     {

   237                     preferredConfig[count+1] = 0;

   238                     count++;

   239                     }

   240 

   241                 break;

   242             case EGL_RED_SIZE:

   243                 if (conf[count+1] != 5)

   244                     {

   245                     preferredConfig[count+1] = 5;

   246                     count++;

   247                     }

   248 

   249                 break;

   250             case EGL_GREEN_SIZE:

   251                 if (conf[count+1] != 6)

   252                     {

   253                     preferredConfig[count+1] = 6;

   254                     count++;

   255                     }

   256 

   257                 break;

   258             case EGL_BLUE_SIZE:

   259                 if (conf[count+1] != 5)

   260                     {

   261                     preferredConfig[count+1] = 5;

   262                     count++;

   263                     }

   264                 break;

   265             default:

   266                 break;

   267             }

   268         }

   269     

   270     TInt index = 0;

   271     

   272     // figure out what API was requested

   273     EGLint api = EGL_NONE;

   274     while (conf[index] != EGL_NONE)

   275         {

   276         if (conf[index] == EGL_RENDERABLE_TYPE)

   277             {

   278             if (conf[index+1]&EGL_OPENVG_BIT)

   279                 {

   280                 api = EGL_OPENVG_BIT;

   281                 if (!eglBindAPI(EGL_OPENVG_API))

   282                     {

   283                     User::Leave(KErrAbort);

   284                     }

   285                 }

   286             else if ( (conf[index+1]&EGL_OPENGL_ES_BIT) ||

   287                       (conf[index+1]&EGL_OPENGL_ES2_BIT) )

   288                 {

   289                 api = conf[index+1];

   290                 if (!eglBindAPI(EGL_OPENGL_ES_API))                

   291                     {

   292                     User::Leave(KErrAbort);

   293                     }

   294                 }

   295             index++;

   296             }

   297         index++;

   298         }         

   299     EGLConfig *configList = NULL;

   300     EGLint numConfigs = 0;

   301     EGLint configSize   = 0;

   302 

   303     // Get the number of possible EGLConfigs

   304     if ( !eglGetConfigs( iEGLDisplay, configList, configSize, &numConfigs ) )

   305        {

   306        User::Leave(KErrAbort);

   307 

   308        }

   309     configSize = numConfigs;

   310     

   311     configList = (EGLConfig*)malloc(sizeof(EGLConfig)*configSize);

   312     if (!configList)

   313         {

   314         User::Leave(KErrNoMemory);

   315         }

   316     

   317 	if( !eglChooseConfig( iEGLDisplay, preferredConfig, configList, configSize, &numConfigs ) )

   318 		{

   319         User::Leave(KErrAbort);

   320 		}

   321 

   322 	TInt confIndex = 0;

   323 	// we should now have a list of configs matching our preferred attributes

   324     for (TInt count = 0;count<numConfigs;count++)

   325         {

   326         EGLint buffer_size;

   327         EGLint red_size;

   328         EGLint green_size;

   329         EGLint blue_size;

   330         EGLint alpha_size;

   331         

   332         eglGetConfigAttrib(iEGLDisplay, configList[count],EGL_BUFFER_SIZE,&buffer_size);

   333         eglGetConfigAttrib(iEGLDisplay, configList[count],EGL_RED_SIZE,&red_size);

   334         eglGetConfigAttrib(iEGLDisplay, configList[count],EGL_GREEN_SIZE,&green_size);

   335         eglGetConfigAttrib(iEGLDisplay, configList[count],EGL_BLUE_SIZE,&blue_size);

   336         eglGetConfigAttrib(iEGLDisplay, configList[count],EGL_ALPHA_SIZE,&alpha_size);

   337 

   338         if (buffer_size == 16 && red_size == 5 && green_size == 6 && blue_size == 5 && alpha_size == 0)

   339             {

   340             confIndex = count;

   341             break;

   342             }

   343         }

   344         

   345     EGLint* context_attrs = NULL;

   346     if (api == EGL_OPENGL_ES2_BIT)

   347         {

   348         context_attrs = (EGLint*)opengl_es2_context_attrs;

   349         }

   350 

   351 	iEGLContext = eglCreateContext( iEGLDisplay, configList[confIndex], NULL, context_attrs );

   352 	if( !iEGLContext )

   353         {

   354         User::Leave(KErrAbort);

   355         }

   356 

   357     EGLint* surface_attrs = NULL;

   358 #if !defined(__WINS__) // no pre multiplied surfaces on wins (yet)

   359     if (api == EGL_OPENVG_BIT)

   360         {

   361         surface_attrs = (EGLint*)openvg_surface_attrs;

   362         }

   363 #endif

   364         

   365 	iEGLSurface = eglCreateWindowSurface( iEGLDisplay, configList[confIndex], &iWindow, surface_attrs );

   366 	if( !iEGLSurface )

   367         {

   368         User::Leave(KErrAbort);

   369         }

   370 	

   371 	eglMakeCurrent( iEGLDisplay, iEGLSurface, iEGLSurface, iEGLContext );        

   372 

   373 

   374     free(configList);

   375     free(preferredConfig);

   376 	

   377     FOREVER

   378         {

   379         TRAPD(cerr, iCompSource = CAlfCompositionSource::NewL(iWindow));

   380         if (!cerr)

   381             {

   382             iCompSource->AddCompositionObserverL(*this);

   383             iCompSource->SetIsBackgroundAnim(ETrue);

   384             iCompSource->SetExtent(TRect(TPoint(0,0),iRealDisplaySize),0);

   385             break;

   386             }

   387         else

   388             {

   389             User::After(5000000);

   390             }

   391         }

   392 

   393     iSurfaceInitialized = ETrue;

   394     

   395     }

   396     

   397 void CBgAnimHost::LoadPluginL()

   398     {

   399     // dig out the skin config from skin server

   400     HBufC* configstr = NULL;

   401     RAknsSrvSession skinsrv;

   402     User::LeaveIfError(skinsrv.Connect());

   403     CleanupClosePushL(skinsrv);

   404     CAknsSrvChunkLookup* cl = skinsrv.CreateChunkLookupL();

   405     CleanupStack::PushL(cl);

   406     CAknsStringItemDef* configitem = static_cast<CAknsStringItemDef*>(cl->LookupAndCreateDefL( KAknsIIDPropertyAnimBgParam )); 

   407     User::LeaveIfNull(configitem);

   408     CleanupStack::PushL(configitem);

   409     configstr = configitem->String().AllocL();

   410     CleanupStack::PopAndDestroy(3); // skinsrv, cl, configitem

   411     CleanupStack::PushL(configstr);

   412     RDebug::Print(_L("----------------------"));

   413     RDebug::Print(_L("backgroundhost config:"));

   414     RDebug::Print(*configstr);

   415     RDebug::Print(_L("----------------------"));

   416     

   417     TLex lex(*configstr);

   418     TPtrC dllname = lex.NextToken();

   419     if (!dllname.Length())

   420         {

   421         User::Leave(KErrNotFound);

   422         }

   423     

   424     User::LeaveIfError(iPluginLibrary.Load(dllname));

   425     plugingetinterfacefunc getif = (plugingetinterfacefunc)iPluginLibrary.Lookup(1);

   426     if (!getif)

   427         {

   428         iPluginLibrary.Close();

   429         User::Leave(KErrNotFound);

   430         }

   431     

   432     iPlugin = (plugin_export_v1_t*) getif(1);

   433 

   434     TPtrC configpath = lex.NextToken();

   435     if (!configpath.Length())

   436         {

   437         User::Leave(KErrNotFound);

   438         }

   439     TBuf8<256> pluginpath;

   440     pluginpath.Copy(configpath);

   441     User::LeaveIfError(iPlugin->initialize((const char*)pluginpath.PtrZ(), KMaxGPUMemUsage));

   442 

   443 //        }

   444 //    else

   445 //        {

   446 //        User::LeaveIfError(iPlugin->initialize("z:\\private\\200286D3", KMaxGPUMemUsage));

   447 //        }

   448 

   449     CleanupStack::PopAndDestroy(); // configstr

   450     

   451     iPlugin->setdisplaydimensions(iDisplaySize.iWidth, iDisplaySize.iHeight);

   452     if (iPlugin->desiredsensors && iPlugin->receivesensordata)

   453         {

   454         const unsigned int* sensors = iPlugin->desiredsensors();

   455         while (*sensors)

   456             {

   457             CSensorListener* listener = NULL;

   458             TRAPD(serr, listener = CSensorListener::NewL(this, *sensors++));

   459             if (!serr)

   460                 {

   461                 iSensorListeners.Append(listener);

   462                 }

   463             }

   464         }

   465     }

   466     

   467 void CBgAnimHost::NewFrame()

   468     {

   469     if (!iRunning)

   470         {

   471         // Stop and exit

   472         CActiveScheduler::Stop();

   473         return;

   474         }

   475     if (!iSurfaceInitialized)

   476         {

   477         return;

   478         }

   479     TTime start;

   480     start.UniversalTime();

   481     iPlugin->produceframe();

   482     eglSwapBuffers(iEGLDisplay, iEGLSurface);

   483     TTime end;

   484     end.UniversalTime();

   485     TInt64 elapsed = end.MicroSecondsFrom(start).Int64();

   486     elapsed/=1000; // convert to milliseconds

   487     

   488     TInt nextcallback = KRefreshTarget-(TInt)elapsed;

   489     if (nextcallback < 1)

   490         nextcallback = 1;

   491     

   492     iTimer->CallBack(nextcallback);

   493     }

   494     

   495     

   496 TInt CBgAnimHost::TimerFunc(TAny* aPtr)

   497     {

   498     CBgAnimHost* me = (CBgAnimHost*)(aPtr);

   499     me->NewFrame();

   500     return ETrue;

   501     }

   502 

   503     

   504 void CBgAnimHost::ExecuteL() 

   505     {

   506     // finally start our timer and scheduler...

   507     iTimer->CallBack(100);

   508     iTimerRunning = ETrue;

   509     iRunning = ETrue;

   510     CActiveScheduler::Start();

   511     }

   512 

   513 void CBgAnimHost::FrameReady(TInt /*aScreenNumber*/)

   514     {

   515     }

   516     

   517 void CBgAnimHost::RunningLowOnGraphicsMemory()

   518     {

   519 /*    iThemeRepositoryListener->GPuMemLow(ETrue);

   520     CompositionTargetHidden();*/

   521     }

   522 

   523 

   524 void CBgAnimHost::GraphicsMemoryGood()

   525     {

   526 /*    CompositionTargetVisible();

   527     iThemeRepositoryListener->GPuMemLow(EFalse);*/

   528     }

   529     

   530 void CBgAnimHost::CompositionTargetHidden()

   531     {

   532     if (!iSurfaceInitialized)

   533         {

   534         // don't bother if we are already in

   535         // a correct state..

   536         return;

   537         }

   538 

   539     RDebug::Print(_L("!!! - HIDDEN - !!!"));

   540     // release gpu resources...

   541     iTimer->Cancel();

   542     iTimerRunning = EFalse;

   543     iPlugin->gpuresourcesavailable(0);

   544     ReleaseWindowSurface(EFalse);

   545     }

   546 

   547 void CBgAnimHost::CompositionTargetVisible()

   548     {

   549     if (iSurfaceInitialized)

   550         {

   551         // don't bother if we are already in

   552         // a correct state..

   553         return;

   554         }

   555 

   556     RDebug::Print(_L("!!! - VISIBLE - !!!"));

   557 

   558     if (!iSurfaceInitialized && iCompSource)

   559         {

   560         iCompSource->RemoveObserver(*this);

   561         delete iCompSource;

   562         iCompSource = NULL;            

   563         }

   564         

   565     TRAPD(err,CreateWindowSurfaceL());

   566     // reclaim gpu resources

   567     if (!err)

   568         {

   569         iPlugin->gpuresourcesavailable(1);

   570         iTimer->CallBack(1);

   571         iTimerRunning = ETrue;

   572         }

   573     }

   574 

   575 void CBgAnimHost::HandleScreenSaverEvent()

   576     {

   577     RDebug::Print(_L("-----------------------------------"));

   578     RDebug::Print(_L("CBgAnimHost::HandleScreenSaverEvent"));

   579     TInt scStatus = iSCPropertyListener->GetScreenSaverStatus();

   580     RDebug::Print(_L("status: %d, timerrunning %d, surfacecreated %d"),scStatus, iTimerRunning, iSurfaceInitialized);

   581     RDebug::Print(_L("-----------------------------------"));

   582     if (scStatus)

   583         {

   584         // screensaver is ON

   585         if (iTimerRunning)

   586             {

   587             RDebug::Print(_L("--- screensaver on, stopping timer ---"));

   588             iTimer->Cancel();

   589             iTimerRunning = EFalse;

   590             }

   591         }

   592     else

   593         {

   594         // screensaver is OFF

   595         if (!iTimerRunning && iSurfaceInitialized)

   596             {

   597             RDebug::Print(_L("--- screensaver off, starting timer ---"));

   598     

   599             iTimerRunning = ETrue;

   600             iTimer->CallBack(1);

   601             }

   602         }

   603     }

   604 

   605 TInt CBgAnimHost::ScreenSaverCallback(TAny* aPtr)

   606     {

   607     CBgAnimHost* me = (CBgAnimHost*) aPtr;

   608     me->HandleScreenSaverEvent();

   609     return EFalse;

   610     }

   611 

   612 void CBgAnimHost::DataReceived( CSensrvChannel& aChannel, TInt aCount, TInt aDataLost )

   613     {

   614     if (iPlugin && iPlugin->receivesensordata);

   615         {

   616         iPlugin->receivesensordata((void*)&aChannel, aCount, aDataLost);

   617         }

   618     }

   619     

   620 void CBgAnimHost::DataError( CSensrvChannel& aChannel, TSensrvErrorSeverity aError )

   621     {

   622     }

   623 

   624 void CBgAnimHost::GetDataListenerInterfaceL( TUid aInterfaceUid, TAny*& aInterface)

   625     {

   626     }