FCL/sf/mw/uiaccelerator: comparison uiacceltk/hitchcock/ServerCore/Src/alfbridge.cpp

equal deleted inserted replaced

-:c9d868f1e20c
+:1801340c26a2
 #ifdef SYMBIAN_BUILD_GCE
 #include <bautils.h>
 #endif
+#ifdef ALF_MEMORYLOGGING
+#include <hal.h>
+#endif
+#include <graphics/fbsrasterizer.h>
+#include <graphics/fbsrasterizerclearcache.h>
 const TInt KVisualTransformationStepRotate    = 0;
 const TReal32 KAlfVisualDefaultOpacity = 1.0f;
 //const TReal32 KAlfVisualDefaultOpacity = 0.5f;
 const TInt KEffectCleanupDelayInMs = 10;
 // Duration to wait if coverage is modified by multiple control groups.
 // This may indicate that topmost application hasn't yet had time to update
 // its layout properly.
 const TInt KAlfCheckCoverageFromMultipleGroups = 20;
+// Duration to wait if visual is not ready for current orientation.
+// 1 unit = 50ms.
+const TInt KAlfCheckVisualIsNotReady = 15;
 NONSHARABLE_CLASS( TAlfBridgeDrawerWrapper ) : public MAlfDrawerScreenInterface
 {
 public:
 TAlfBridgeDrawerWrapper(CAlfBridge& aBridge);
 TAlfControlGroupEntry entry;
 entry.iControlGroup = group;
 entry.iWindowGroupNodeId = aWindowGroupNodeId;
 entry.iClientWindowGroupId = aClientWindowGroupId;
 entry.iSecureId = aSecureId;
+// Add to the control group. HandleGfxEventL effect redirection will need this information
+entry.iScreenNumber = aScreenNumber;
+iAlfScreens[aScreenNumber]->iControlGroups.Append(entry);
+CleanupStack::Pop(group);
 // we have received start effect for this group, but the group did not exist in alf universe at the time. hide the group.
 if (iFSFxData
 && (iFSFxData->State() == EWaitingWindowGroup || iFSFxData->State() == EEndFullScreenReceivedWaitingWindowGroup)
 && iFSFxData->iToSecureId == aSecureId)
 {
 // Effect failed, reset state
 __ALFFXLOGSTRING1("CAlfBridge::CreateControlGroupL - effect failed on layout 0x%x", layout);
 HandleGfxStopEvent( EFalse ); // destroys iFSFxData and iFSFXDataPart2
 }
 }
-entry.iScreenNumber = aScreenNumber;
-//        entry.iRole = EHuiWindowGroupContainer;
-iAlfScreens[aScreenNumber]->iControlGroups.Append(entry);
-CleanupStack::Pop(group);
 if (iAlfScreens[aScreenNumber]->iDisplay)
 ShowControlGroupL(iAlfScreens[aScreenNumber]->iDisplay->Roster(), *group, KHuiRosterShowAtTop, aScreenNumber);
 AMT_INC_COUNTER( iTotalControlGroupCount );
 iTempRegion.AddRect(fullscreen);
 iTempRegion.Tidy();
 fullscreenCovered = ETrue;
 firstAlfControlGroupFound = ETrue;  // change flag so that we don't go in this branch again
 }
+else
+{
+hostContainer->SetFlags(EHuiVisualFlagInactive);
+}
 }
 }
 else // else put as inactive
 {
 hostContainer->SetFlags(EHuiVisualFlagInactive);
 case EAlfDSIncludeToVisibilityCalculation:
 {
 HandleIncludeToVisibilityCalculationL( data );
 break;
 }
+case EAlfDSSetScreenDeviceValid:
+{
+HandleSetScreenDeviceValidL( data );
+break;
+}
 case EAlfDSSetWindowArea:
 {
 HandleSetWindowAreaL( data );
 break;
 }
 			{
 			__ALFLOGSTRING("CAlfBridge::HandleNewWindowL: Unknown window node type received !");
 			}
 		}
 	iAlfScreens[0]->SetVisualTreeVisibilityChanged(ETrue);
+#ifdef ALF_MEMORYLOGGING
+ReportMemory();
+#endif
 	}
 // ---------------------------------------------------------------------------
 // HandleDestroyWindow
 // ---------------------------------------------------------------------------
 __ALFLOGSTRING("CAlfBridge::HandleIncludeToVisibilityCalculationL, EAlfDSIncludeToVisibilityCalculation: Visual not found!");
 }
 }
 // ---------------------------------------------------------------------------
+// HandleSetScreenDeviceValidL
+// ---------------------------------------------------------------------------
+//
+void CAlfBridge::HandleSetScreenDeviceValidL( TAlfBridgerData& aData )
+{
+	TInt windowNodeId = aData.iInt2;
+	TAlfWindowAttributes* windowAttributes = (TAlfWindowAttributes*) (*iHost)->GetVarDataL( (TInt)aData.iPtr );
+	// fetch visual
+	CHuiCanvasVisual* viz = (CHuiCanvasVisual*)FindVisual(windowNodeId);
+	if (viz)
+		{
+#ifdef HUI_DEBUG_TRACK_DRAWING
+if ( viz->Tracking() )
+{
+RDebug::Print(_L("CAlfBridge::HandleSetScreenDeviceValidL - Tracked visual"));
+}
+#endif
+		if ( windowAttributes->iActive )
+		    {
+		    viz->ClearCanvasFlags( EHuiCanvasVisualFlagNotReady );
+		    }
+		else
+		    {
+		    viz->SetCanvasFlags( EHuiCanvasVisualFlagNotReady );
+		    }
+	    iAlfScreens[0]->SetVisualTreeVisibilityChanged(ETrue);
+		}
+	else
+		{
+		__ALFLOGSTRING("CAlfBridge::HandleSetScreenDeviceValidL, EAlfDSSetScreenDeviceValid: Visual not found!");
+		}
+}
+// ---------------------------------------------------------------------------
 // HandleSetWindowAreaL
 // ---------------------------------------------------------------------------
 //
 void CAlfBridge::HandleSetWindowAreaL( TAlfBridgerData& aData )
 	{
 			else
 				{
 				__ALFLOGSTRING1("CAlfBridge::HandleReorderWindowL, EAlfDSReorder: WS window group going to: %d ",windowAttributes->iOrdinalPosition);
 				}
 			#endif
+TBool wasInvalidReachable = IsVisualNotReadyReachable();
 			CHuiControlGroup* controlGroup = FindControlGroup(windowGroupNodeId);
 if (!controlGroup)
 {
 				{
 				__ALFLOGSTRING1("CAlfBridge::HandleReorderWindowL, EAlfDSReorder: Control group not found! Id: %d ", windowNodeId );
 				}
 			ReorderAlfControlGroupsL();
+// Usually, layout switch is initiated by akncapserver before window group in new orientation
+// becomes visible. However, sometimes either akncapserver isn't fast enough or then applications
+// perform operations in wrong order. To reduce flickering, uiaccelerator provides implicit blanker.
+// We will check if there is a visual that is not ready for current orientation.
+// If such visual is found before fullscreen is covered then we will enable
+// implicit blanker. That gives akncapserver some time to start layout switch.
+if (!wasInvalidReachable && IsVisualNotReadyReachable())
+{
+iLayoutSwitchEffectCoordinator->ImplicitBlank();
+}
 			break;
 			}
 		case EAlfWinTreeNodeClient:
 		case EAlfWinTreeNodeRoot:
 		case EAlfWinTreeNodeAnim:
 	TInt windowGroupNodeId = aData.iInt1;
 	TInt windowNodeId = aData.iInt2;
 	TAlfWindowAttributes* windowAttributes = (TAlfWindowAttributes*)(*iHost)->GetVarDataL( (TInt)aData.iPtr );
 	// fetch visual
 	CHuiCanvasVisual* viz = FindVisual(windowNodeId);
+	CHuiControlGroup* controlgroup = FindControlGroup(windowGroupNodeId, 0);
 // We should not do this for alf window, but renderstage does not know if it is
 // handling alf window or other window, so we ignore the request here if needed.
 // TODO: When alf apps work in multiple display, check here for every displays alf groups...
-	if (viz && iAlfWindowGroupNodeId != windowGroupNodeId)
+	if (viz && iAlfWindowGroupNodeId != windowGroupNodeId && controlgroup && controlgroup->SecureId() != iAlfSecureId )
 		{
 viz->SetLayerExtent(windowAttributes->iSurfaceExtent);
 		// Set surface extend area to be cleared with fully transparent color
 		// Note: does not support extend that is bigger that the visual
 		// if surface extent is (0,0,0,0) then the background item array is reseted
 {
 // All children in the tree are not faded, do not apply effect on children.
 effectFlags |= KHuiFxEffectExcludeChildrenFlag;
 //RDebug::Print(_L("CAlfBridge::SetupFadeEffectL - no children faded by parent"));
 }
-__ALFFXLOGSTRING1("CAlfBridge::SetupFadeEffectL - insert fade 0x%x", &aVisual);
-TRAP( err, engine->LoadEffectL(*iFadeEffectFile, effect, aVisual.Effectable(), NULL, NULL, 0, effectFlags ) );
+if (iHuiEnv->MemoryLevel() <= EHuiMemoryLevelLowest)
-didFadeEffectLoad = ETrue;
+{
+__ALFFXLOGSTRING("CAlfBridge::SetupFadeEffectL - Skipping because in SW rendering mode");
+didFadeEffectLoad = EFalse;
+}
+else
+{
+__ALFFXLOGSTRING1("CAlfBridge::SetupFadeEffectL - insert fade 0x%x", &aVisual);
+TRAP( err, engine->LoadEffectL(*iFadeEffectFile, effect, aVisual.Effectable(), NULL, NULL, 0, effectFlags ) );
+didFadeEffectLoad = ETrue;
+}
 		}
 	}
 }
 else
 {
 // NOTE! If embedded application effects are implemented, this will need revision
 // ---------------------------------------------------------------------------
 void CAlfBridge::HandleGfxRedirection(CFullScreenEffectState& aEvent, CHuiLayout*& aToLayout)
 {
+__ALFFXLOGSTRING2("CAlfBridge::HandleGfxRedirection - Redirection check for SecureId 0x%x. Effect setup result: %d.", aEvent.iToSecureId, aEvent.iSetupDone);
 TInt windowGroupNodeId = FindWindowGroupNodeId(*((*aToLayout).Owner().ControlGroup()));
 CHuiControlGroup* chainedGroup = NULL;
 // check, if the effect is being asked for chained application. This propably indicates that there are two or more instances of it and
 // effect was supposed to go to the single standalone instance
 {
 __ALFFXLOGSTRING2("CAlfBridge::HandleGfxRedirection - Wg id: %d IS chained. Index: %d", windowGroupNodeId, i);
 }
 }
 groupList.Close();
-// If there are multiple standalone app groups (e.g. single application having multiple groups), effecting anything would be a guess.
+// Skip effect redirection if the end result is uncertain. This is the case, if
+// there are multiple standalone app groups (e.g. single application having multiple groups),
 if (standaloneGroups>1)
 {
 chainedGroup = NULL;
 aEvent.iIsRedirected = ETrue;
 if (iFSFXDataPart2)
 // Which group is chained to this group?
 TUint32 chainedId = FindChainedGroup(windowGroupNodeId);
 chainedGroup = FindControlGroup(chainedId);
 }
-if (chainedGroup)
+	// Redirection is skipped if the host layout has been already prepared (in practice added
-{
+	// to iEffectCleanupStack) for the effect.
-__ALFFXLOGSTRING2("CAlfBridge::HandleGfxEffects - Chained app found for this application. Transferring effect from 0x%x to 0x%x.", aToLayout->Owner().ControlGroup()->SecureId(), chainedGroup->SecureId());
+if (chainedGroup && !aEvent.iSetupDone)
+{
+__ALFFXLOGSTRING2("CAlfBridge::HandleGfxRedirection - Chained app found for this application. Transferring effect from 0x%x to 0x%x.", aToLayout->Owner().ControlGroup()->SecureId(), chainedGroup->SecureId());
 aToLayout = (CHuiLayout*)&chainedGroup->Control(0).Visual(0);
 // we'll change the original effect request to point to this new group. Thus, if effect is
 // canceled, it will be removed from the right place.
-aEvent.iIsRedirected = ETrue;
 aEvent.iToSecureId = chainedGroup->SecureId(); // Update the effect
 aEvent.iToWg = FindClientWindowGroupId(*chainedGroup);
 if (iFSFXDataPart2)
 {
-iFSFXDataPart2->iIsRedirected = ETrue;
 iFSFXDataPart2->iToSecureId = aEvent.iToSecureId;
 iFSFXDataPart2->iToWg = aEvent.iToWg;
 }
 }
+else
+{
+__ALFFXLOGSTRING2("CAlfBridge::HandleGfxRedirection - Skip redirection for SecureId 0x%x. Chained group: 0x%x", aEvent.iToSecureId, chainedGroup);
+}
+// Redirection attemp is allowed to happen only once, because this redirects effects for
+	// _running_ embedded applications that must exist at the time of the request.
+	// We are not interested in the embedded applications effects. Start effects for embedded applications
+	// are not currently supported.
+aEvent.iIsRedirected = ETrue;
+if (iFSFXDataPart2)
+{
+iFSFXDataPart2->iIsRedirected = ETrue;
+}
 }
 // ---------------------------------------------------------------------------
 // HandleGfxEventL
 //
 // ---------------------------------------------------------------------------
 //
 TBool CAlfBridge::HandleGfxEventL(CFullScreenEffectState& aEvent, CHuiLayout* aToLayout, CHuiLayout* /*aFromLayout */)
 {
-__ALFFXLOGSTRING3("CAlfBridge::HandleGfxEventL - To SecureUid: 0x%x, From SecureUid: 0x%x, effect %S", aEvent.iToSecureId, aEvent.iFromSecureId, aEvent.iEffectName);
+__ALFFXLOGSTRING4("CAlfBridge::HandleGfxEventL - Operation: %d, To SecureUid: 0x%x, From SecureUid: 0x%x, effect %S", aEvent.iOperation, aEvent.iToSecureId, aEvent.iFromSecureId, aEvent.iEffectName);
 __ALFFXLOGSTRING3("CAlfBridge::HandleGfxEventL - To layout: 0x%x Effect handle: %d, Action: %d", aToLayout, aEvent.iHandle, aEvent.iAction);
 if (!aEvent.iIsRedirected)
 {
 HandleGfxRedirection(aEvent, aToLayout);
 aToLayout->iOpacity.Set(1.0f);
 }
 if (aToLayout)
 {
+// 1. If this is timeout, then we should be update the
-// However, if this is timeout, then we should be having update to date screenshot for the long app start effect usage
+						//    screenshot for the long app start effect usage.
-// For the second part of the effect, screenshot must be update. Thus the transition may continue smoothly, where app_start_long.fxml finished.
+// 2. For the second part of the effect, screenshot must be
-if ((aEvent.iLongAppStartTimeout && !aToLayout->StoredRenderBuffer())
+						//    update. Thus the transition may continue smoothly, where app_start_long.fxml finished.
-|| aEvent.iTwoPhaseEffect == CFullScreenEffectState::ESecondPartActive // update the screenshot, that the app_start effect can use the end result of app_start_long.fxml as input
+						// 3. Sometimes BeginFullScreen has not run for the effect. For instance
-								)
+						//    when window group is created after EndFullScreen was received.
+TBool requiresScreenshot = NeedsStoredBuffers(iHuiEnv->EffectsEngine(), *aEvent.iEffectName);
+TBool hasScreenshot = TBool(aToLayout->StoredRenderBuffer());
+if ((aEvent.iLongAppStartTimeout && !hasScreenshot)  // (1)
+|| aEvent.iTwoPhaseEffect == CFullScreenEffectState::ESecondPartActive // (2)
+								|| (requiresScreenshot && !hasScreenshot) // (3)
+)
 {
 __ALFFXLOGSTRING1("CAlfBridge::HandleGfxEventL  - taking screenshot for the timeout appstart effect. Handle: %d",  aEvent.iHandle );
 aToLayout->SetStoredRenderBufferModificationsEnabled(ETrue);
 TBool neededStoredBuffers(EFalse); // dummy
 StoreLayoutIfRequiredByEffectL(aToLayout, aEvent, neededStoredBuffers);
 // Only changing the effect is required.
 layoutEffectable = ETrue;
 }
 else
 {
+								// SetupEffectLayoutContainerL always returns ETrue. Code cleanup needed.
 layoutEffectable = SetupEffectLayoutContainerL(aEvent.iHandle,aToLayout, ETrue, EFalse, aEvent.iCanDestroyOrHideImmediately);
 }
-aEvent.iSetupDone = layoutEffectable;
+aEvent.iSetupDone = ETrue;
+if (iFSFXDataPart2)
+{
+iFSFXDataPart2->iSetupDone = aEvent.iSetupDone;
+}
 aToLayout->SetStoredRenderBufferModificationsEnabled(ETrue);
 }
-if (layoutEffectable)
+if (layoutEffectable) // Note, this is always ETrue
 {
 TInt effectFlags = 0;
 TInt activeEffectGroup = engine->ActiveGroupEffect();
 if (activeEffectGroup != KErrNotFound)
 {
 }
 CControlEffectState* fxData = new (ELeave) CControlEffectState;
 CleanupStack::PushL(fxData);
 fxData->ConstructL(action, stream);
-iControlEffectData = fxData;
-CleanupStack::Pop(fxData);
 // We now have all the data sent to us.
 stream.Release();
 // We need to pass the filename from the transeffect plugin that handles the controls
 // that define which effect is used for the selected skin or the selected application
 CHuiCanvasVisual* visual = FindVisualByClientSideIds(fxData->iClientHandle, fxData->iClientGroupHandle);
 if (visual)
 {
-HandleGfxControlEventL(*iControlEffectData, visual);
+HandleGfxControlEventL(*fxData, visual);
+CleanupStack::PopAndDestroy(fxData);
 }
 else
 {
+iControlEffectData = fxData; // move ownership
+// Control was not found. Apply effect later when control appears in HandleNewWindow
 __ALFFXLOGSTRING2("CAlfBridge::HandleGfxControlEffectsL - Control not found. iClientHandle %d, iClientGroupHandle %d",
 iControlEffectData->iClientHandle,
 iControlEffectData->iClientGroupHandle);
+CleanupStack::Pop(fxData);
 return;
 }
 iAlfScreens[0]->iDisplay->SetDirty();
 iHuiEnv->ContinueRefresh();
-delete iControlEffectData;
-iControlEffectData = NULL;
 __ALFFXLOGSTRING("HandleGfxControlEffectsL - end");
 }
 void CAlfBridge::HandleGfxControlEventL(CControlEffectState& aEvent,
 sourceViz->Layout()->Remove(sourceViz);
 }
 sourceViz->Owner().Remove(sourceViz);
 delete sourceViz;
-__ALFFXLOGSTRING1("CAlfBridge::RemoveTemporaryPresenterItem - Destroying sourceViz: 0x%x", sourceViz);
+__ALFFXLOGSTRING1("CAlfBridge::CleanFxItem - Destroying sourceViz: 0x%x", sourceViz);
 aEffectItem.iEffectedVisual = NULL;
 }
 else
 {
 DestroyWindow(sourceViz, ETrue);
 // CleanFxVisual removes the temporary presenter visual, and unbinds it from the source.
 TBool CAlfBridge::CleanFxVisual(CHuiVisual* aVisual,
 TInt aHandle)
 {
-__ALFFXLOGSTRING2("CAlfBridge::RemoveTemporaryPresenterVisual - cleaning handle: %d, 0x%x", aHandle, aVisual);
+__ALFFXLOGSTRING2("CAlfBridge::CleanFxVisual - cleaning handle: %d, 0x%x", aHandle, aVisual);
 TInt visualsRemoved = 0;
 for (TInt i = 0; i < iEffectCleanupStack.Count(); i++)
 {
 TEffectCleanupStruct& effectItem = iEffectCleanupStack[i];
 if (aVisual == effectItem.iEffectedVisual ||
 if (!iSwRenderingEnabled && iManualRefreshTimer)
 {
 iManualRefreshTimer->Cancel();
 }
+if (!aEnable)
+{
+ClearRasterizerCache();
+}
+#ifdef ALF_MEMORYLOGGING
+ReportMemory();
+#endif
 }
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 //
 if ( visualIsActive )
 {
 TRect displayRect = visualDisplayRect;
 visualDisplayRect = canvasVisual->CommandBufferCoverage(aOrientation);
+if (aDuration <= KAlfCheckVisualIsNotReady && !visualRectIsCovered && visualIsVisible &&
+!displayRect.IsEmpty() && (canvasVisual->CanvasFlags() & EHuiCanvasVisualFlagNotReady))
+{
+__ALFLOGSTRING("CAlfBridge::IsLayoutSwitchReady not ready - invalid screen device reachable");
+visualTreeReady = EFalse;
+break;
+}
 // Heuristic: Check that visual drawing isn't completely empty.
 if ( aDuration <= KAlfCheckVisualDrawingNotEmpty && !visualRectIsCovered &&
 visualIsVisible && visualDisplayRect.IsEmpty() )
 {
 __ALFLOGSTRING("CAlfBridge::IsLayoutSwitchReady not ready - no drawing");
 } // for loop end : children checking loop
 return visualTreeReady;
 }
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+//
+TBool CAlfBridge::IsVisualNotReadyReachable()
+{
+TBool invalidReachable = ETrue;
+if (!iAlfScreens.Count())
+{
+return EFalse;
+}
+iTempRegion.Clear();
+iTempRegion2.Clear();
+CAlfScreen* screen = iAlfScreens[0];
+TRect fullscreen = TRect(TPoint(0,0), screen->Size());
+TInt orientation = screen->iDisplay->Orientation();
+TBool fullscreenCovered = EFalse;
+	TBool alfClientWindowGroupVisible = EFalse;
+// Skip the topmost (effect) layer, start from floating sprite group
+for (TInt j=screen->iDisplay->Roster().Count() - screen->FixedControlGroupCount(); j>=0; j--)
+{
+CHuiControlGroup& controlgroup = screen->iDisplay->Roster().ControlGroup(j);
+CHuiControl& control = controlgroup.Control(0);
+if (control.Role() == EHuiFpsIndicatorContainer)
+{
+// FPS container doesn't contain canvas visuals
+continue;
+}
+CHuiCanvasVisual* layout = (CHuiCanvasVisual*)&control.Visual(0);
+// For optimization reasons, check if all visuals below in Z-order are covered
+if (!fullscreenCovered)
+{
+fullscreenCovered = IsRectCoveredByRegion(fullscreen, iTempRegion);
+}
+if (fullscreenCovered)
+{
+break;
+}
+// ALF applications are handled by checking if their visuals cover the whole screen.
+if (control.Role() == EHuiSessionContainer)
+{
+CHuiLayout* hostContainer = control.ContainerLayout( NULL );
+TInt flags = hostContainer->Flags();
+if (alfClientWindowGroupVisible)
+{
+// check visual sizes if client has not made this control group hidden
+if(!(flags&EHuiVisualFlagUnderOpaqueHint))
+{
+if(iAppUi)
+{
+CAlfAppSrvSessionBase* alfSrvSession = iAppUi->SrvSessionForControlGroup(controlgroup);
+TInt clientWindowGroupId = alfSrvSession->ClientWindowGroup();
+// checking the case if there are multiple alf application openend.
+if (clientWindowGroupId == iAppUi->GetLastActiveClient())
+{
+return EFalse;
+}
+}
+}
+}
+continue;
+}
+TBool hasActiveVisualsInVisualTree(EFalse);
+if (alfClientWindowGroupVisible && (controlgroup.ResourceId() == iAlfWindowGroupNodeId))
+{
+invalidReachable =
+IsVisualNotReadyReachableRecursive( layout, controlgroup, control,
+hasActiveVisualsInVisualTree, fullscreen, screen,
+IsVisualOpaque(*layout), alfClientWindowGroupVisible);
+}
+else
+{
+invalidReachable =
+IsVisualNotReadyReachableRecursive( layout, controlgroup, control,
+fullscreenCovered, fullscreen, screen,
+IsVisualOpaque(*layout), EFalse);
+}
+if (invalidReachable)
+{
+// Problem found in IsInvalidScreenDeviceVisualReachableRecursive
+break;
+}
+if ( controlgroup.iAlfApp && layout->iOpacity.Now() > 0.0f )
+{
+alfClientWindowGroupVisible = ETrue;
+}
+}
+iTempRegion2.Clear();
+return invalidReachable;
+}
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+//
+TBool CAlfBridge::IsVisualNotReadyReachableRecursive(
+CHuiLayout* aLayout,
+CHuiControlGroup& aControlGroup,
+CHuiControl& aControl,
+TBool& aFullscreenCovered,
+const TRect& aFullscreen,
+CAlfScreen* aScreen,
+TBool aChildCanBeOpaque,
+TBool aOnlyForEmbeddedAlfApp)
+{
+TBool invalidReachable = EFalse;
+TRect visualDisplayRect;
+TBool visualRectIsCovered = EFalse;
+TBool visualIsOpaque = EFalse;
+TBool visualIsActive = EFalse;
+CHuiCanvasVisual* canvasVisual = NULL;
+for (TInt i = aLayout->Count() - 1; i >= 0; i--)
+{
+visualDisplayRect = TRect(0,0,0,0);
+visualRectIsCovered = EFalse;
+visualIsOpaque = EFalse;
+visualIsActive = EFalse;
+canvasVisual = (CHuiCanvasVisual*)(&aLayout->Visual(i));
+// Distraction windows are completely ignored.
+TBool distractionWindow = (canvasVisual->CanvasFlags() & EHuiCanvasFlagDistractionWindow);
+if ( distractionWindow )
+{
+continue;
+}
+visualIsOpaque = aChildCanBeOpaque && IsVisualOpaque(*canvasVisual);
+TBool visualIsVisible = (canvasVisual->iOpacity.Now() > 0.01f);
+if (canvasVisual->Count() && visualIsVisible)
+{
+invalidReachable = IsVisualNotReadyReachableRecursive( canvasVisual, aControlGroup, aControl,
+aFullscreenCovered, aFullscreen, aScreen,
+visualIsOpaque, EFalse);
+if (invalidReachable)
+{
+break;
+}
+}
+// Calculate visual display rect
+visualDisplayRect = canvasVisual->DisplayRect();
+ClipVisualRect(visualDisplayRect, aLayout->DisplayRect());
+ClipVisualRect(visualDisplayRect, aFullscreen);
+// Check if covered.
+if (aFullscreenCovered)
+{
+visualRectIsCovered = ETrue;
+}
+else
+{
+// Check if this visual is covered by other opaque visuals which rects are in "covered" region
+// it should not check for alf event window group, when we have embedded alf application,
+// because we have assumed that alf app will have full screen covered
+if(!aOnlyForEmbeddedAlfApp)
+{
+visualRectIsCovered = IsRectCoveredByRegion(visualDisplayRect, iTempRegion);
+}
+}
+	    // Determine if visual is active from coverage point of view.
+visualIsActive = EFalse;
+if (visualRectIsCovered)
+{
+if (!(canvasVisual->Flags() & EHuiVisualFlagAlwaysDraw))
+{
+visualIsActive = EFalse;
+}
+else
+{
+visualIsActive = ETrue;
+}
+}
+else
+{
+			visualIsActive = ETrue;
+}
+// Sprites and effects as we consider them always as transparent and also
+// if controlgroup is transformed somehow
+if (aControl.Role() == EHuiFullScreenEffectContainer ||
+aControl.Role() == EHuiWindowFloatingSpriteContainer ||
+aControlGroup.IsTransformed())
+{
+visualIsOpaque = EFalse;
+}
+// Check that command buffers are ok.
+if ( visualIsActive )
+{
+if (!visualRectIsCovered && visualIsVisible && !visualDisplayRect.IsEmpty() &&
+(canvasVisual->CanvasFlags() & EHuiCanvasVisualFlagNotReady))
+{
+__ALFLOGSTRING("CAlfBridge::IsLayoutSwitchReady not ready reachable");
+invalidReachable = ETrue;
+break;
+}
+}
+if (visualIsActive && visualIsOpaque && !visualRectIsCovered)
+{
+// New visibility system takes only window shape into account.
+if ( canvasVisual->CanvasFlags() & EHuiCanvasFlagIncludeToVisibilityCalculation )
+{
+if ( !canvasVisual->HasCustomShape() )
+{
+TRect displayRect(canvasVisual->DisplayRect());
+ClipVisualRect(displayRect, aLayout->DisplayRect());
+ClipVisualRect(displayRect, aFullscreen);
+iTempRegion.AddRect(displayRect);
+iTempRegion.Tidy();
+}
+else
+{
+TRect displayRect = canvasVisual->DisplayRect();
+const TRegion& region = canvasVisual->ShapeRegion();
+TPoint delta = -canvasVisual->ShapeOrigin() + displayRect.iTl;
+for (TInt i = 0; i < region.Count(); ++i)
+{
+TRect coveredRect(region[i]);
+coveredRect.Move(delta);
+ClipVisualRect(coveredRect, aFullscreen);
+iTempRegion.AddRect(coveredRect);
+}
+iTempRegion.Tidy();
+}
+}
+}
+} // for loop end : children checking loop
+return invalidReachable;
+}
 TBool CAlfBridge::IsFullScreenDrawnRecursiveAlfContent(CHuiVisual* aVisual, TRect& aFullScreen)
 {
 if(aVisual)
 {
 TInt flags = aVisual->Flags();
 }
 }
 return hasAlfContent;
 }
+void CAlfBridge::ReportMemory()
+{
+#ifdef ALF_MEMORYLOGGING
+TInt totalSpaceAllocated = 0;
+TInt cellsAllocatedInHeap = User::AllocSize(totalSpaceAllocated);
+TInt largestFreeBlock = 0;
+TInt totalFreeSpaceInHeap = User::Available(largestFreeBlock);
+TInt freeRAM = 0;
+if ( HAL::Get( HALData::EMemoryRAMFree, freeRAM ) != KErrNone )
+{
+freeRAM = -1;
+}
+TInt timestamp = User::NTickCount();
+RDebug::Printf("%x CAlfBridge::ReportMemory - Allocated space: %d, Amount of allocated cells: %d, Largest free block: %d, Free space in heap: %d",
+timestamp,
+totalSpaceAllocated,
+cellsAllocatedInHeap,
+largestFreeBlock,
+totalFreeSpaceInHeap);
+RDebug::Printf("%x CAlfBridge::ReportMemory - Free RAM in system: %d", timestamp, freeRAM);
+#endif
+}
+void CAlfBridge::ClearRasterizerCache()
+{
+CFbsRasterizer* rasterizer = CFbsBitmap::Rasterizer();
+MFbsRasterizerClearCache* cacheInterfacePtr = NULL;
+rasterizer->GetInterface(TUid::Uid(KUidFbsRasterizerClearCache), (TAny*&)cacheInterfacePtr);
+if (cacheInterfacePtr)
+{
+cacheInterfacePtr->ClearCache();
+}
+}
 // end of file

branch	RCL_3
changeset 50	1801340c26a2
parent 49	c9d868f1e20c
child 51	e5af45d51884