|
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 } |