diff -r ae942d28ec0e -r 2455ef1f5bbc javauis/lcdui_akn/javalcdui/src/CMIDEnv.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/javauis/lcdui_akn/javalcdui/src/CMIDEnv.cpp Wed Sep 01 12:33:18 2010 +0100 @@ -0,0 +1,577 @@ +/* +* 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: +* +*/ + +#include +#include +#include +#include "CMIDEnv.h" +#include "CMIDToolkit.h" +#include "CMIDNotify.h" +#include "CMIDKeyTranslator.h" +#include "CMIDToLcduiObserver.h" + +#ifdef RD_JAVA_NGA_ENABLED +#include +#include +#include +#endif // RD_JAVA_NGA_ENABLED + +const TUint16 KCharComma = ','; + +CMIDEnv::CMIDEnv(CMIDToolkit* aToolkit, const TSize& aSize) + : iToolkit(aToolkit) + , iObservers(EGranularity) + , iCanvasAssumedSize(aSize) + , iToLcduiObserver(NULL) +#ifdef RD_JAVA_NGA_ENABLED + , iHardwareStatus(0) +#endif +{ + iCanvasData.iLock.CreateLocal(); +} + +void CMIDEnv::ConstructL() +{ + iKeyTranslator = new(ELeave) CMIDKeyTranslator(*this); + iKeyTranslator->ConstructL(); + iToLcduiObserver = new(ELeave) CMIDToLcduiObserver(); + + // On a non-full-screen (normal) mode Canvas the background image must be initially shown, + // if the value of the Nokia-UI-Enhancement attribute is "CanvasHasBackground". The + // attribute may be placed in the JAD or the manifest. + iCanvasData.iHasBackground = MidletAttributeContainsVal( + LcduiMidletAttributes::KAttribUIEnhancement, + LcduiMidletAttributeValues::KUIEnhCanvasBackground); +#ifdef RD_JAVA_NGA_ENABLED + InitHardwareStatusL(); +#endif // RD_JAVA_NGA_ENABLED +} + +CMIDEnv::~CMIDEnv() +{ + if (iToLcduiObserver) + { + delete iToLcduiObserver; + iToLcduiObserver = NULL; + } + delete iKeyTranslator; + iObservers.Close(); + iCanvasData.iLock.Close(); +} + +void CMIDEnv::SetUtils(MMIDUtils* aUtils) +{ + iKeyTranslator->SetUtils(aUtils); +} + +TPtrC CMIDEnv::MidletName() const +{ + return iToolkit->MidletName(); +} + +TUid CMIDEnv::MidletUid() const +{ + return iToolkit->MidletUid(); +} + +TPtrC CMIDEnv::MidletHome() const +{ + return iToolkit->MidletHome(); +} + +#ifdef RD_SCALABLE_UI_V2 +TUid CMIDEnv::MidletSuiteUid() +{ + if (!iMidletSuiteUid.iUid) + { + //Midlet suite uid is located inside brackets in the midlet home path. + const TChar KUidStart = '['; + const TChar KUidEnd = ']'; + + const TPtrC midletHome = MidletHome(); + + //Finding start and end positions + TInt startPos = midletHome.Locate(KUidStart) + 1; + TInt endPos = midletHome.LocateReverse(KUidEnd); + + if (startPos != KErrNotFound && endPos != KErrNotFound && + startPos < endPos && endPos <= midletHome.Length()) + { + //Creating new pointer descriptor representing the midlet suite uid + const TPtrC uidDesc = midletHome.Mid(startPos, endPos - startPos); + + if (uidDesc.Length()) + { + //Creating unsigned integer out of the hex string. + TUint uint; + TLex lexer(uidDesc); + TInt err = lexer.Val(uint, EHex); + + if (err == KErrNone) + { + iMidletSuiteUid = TUid::Uid(uint); + } + else + { + iMidletSuiteUid = TUid::Uid(KNullUidValue); + } + } + else + { + iMidletSuiteUid = TUid::Uid(KNullUidValue); + } + } + else + { + iMidletSuiteUid = TUid::Uid(KNullUidValue); + } + } + return iMidletSuiteUid; +} +#endif // RD_SCALABLE_UI_V2 + + +TBool CMIDEnv::PostJavaEvent +( + MMIDComponent& aSource, + TSourceType aSourceType, + TEventType aEventType, + TInt aEventData, + TInt aEventData1, + TInt aEventData2 +) +{ +#ifdef TRACE_EVENTS + RDebug::Print(_L("CMIDEnv::PostJavaEvent(%x,%d,%d,%d,%d,%d)"), + aSource, + aSourceType, + aEventType, + aEventData,aEventData1, aEventData2); +#endif + switch (aSourceType) + { + case EItem: + return iToolkit->PostItemEvent(aSource, aEventType, aEventData, aEventData1, aEventData2); + case EDisplayable: + return iToolkit->PostDisplayableEvent(aSource, aEventType, aEventData, aEventData1); + case ECanvasGraphicsItemPainterEvent: + return iToolkit->PostCanvasGraphicsItemPainterEvent(aSource, aEventType, aEventData, aEventData1); + default: + ASSERT(EFalse); + } + return EFalse; +} + +TBool CMIDEnv::PostJavaEvent(MMIDComponent& aSource,TSourceType aSourceType,TEventType aEventType,TInt aEventData) +{ + return PostJavaEvent(aSource, aSourceType, aEventType, aEventData, 0, 0); +} + +TBool CMIDEnv::PostJavaEvent(MMIDComponent& aSource,TSourceType aSourceType,TInt aEventData) +{ + return PostJavaEvent(aSource, aSourceType, ENoType, aEventData, 0, 0); +} + +TBool CMIDEnv::PostMidletEvent(TEventType aEventType) +{ + return iToolkit->PostDisplayEvent(aEventType); +} + +MMIDNotifyEvent* CMIDEnv::NewNotifyL(MMIDComponent& aSource) +{ + return new(ELeave) CMIDNotifyEvent(iToolkit->ComponentPeer(aSource)); +} + +TBool CMIDEnv::PostJavaNotify(MMIDNotifyEvent* aNotifyEvent) +{ + CMIDNotifyEvent* notify = static_cast(aNotifyEvent); + return iToolkit->PostEvent(notify, CJavaEventBase::ENotifyPriority); +} + +TBool CMIDEnv::TranslateKeyL(TMIDKeyEvent& aEvent, const TKeyEvent& aWsEvent, TEventCode aType) +{ + return iKeyTranslator->TranslateL(aEvent, aWsEvent, aType); +} + +TBool CMIDEnv::PostKeyEvent(MMIDComponent& aSource, TMIDKeyEvent& aEvent) +{ + return iKeyTranslator->PostKeyEvent(aSource, aEvent); +} + +void CMIDEnv::ResetKeys() +{ + iKeyTranslator->Reset(); +} + +MMIDDisplayable* CMIDEnv::Current() +{ + return iToolkit->Current(); +} + +/** + * Set the zoom size which may be queried by Canvas in the + * plugin. This is a relic from when Canvas was implemented + * in the framework. Should be deprecated. + */ +void CMIDEnv::SetCanvasZoomSize(const TSize& aSize) +{ + iCanvasZoomSize=aSize; +} + +/** + * Get the zoom size - used by the Canvas in the plugin. + * Relic from when Canvas was implementd in the framework. + * Should be deprecated. + */ +TSize CMIDEnv::CanvasZoomSize() +{ + return iCanvasZoomSize; +} + +TSize CMIDEnv::CanvasAssumedSize() +{ + return iCanvasAssumedSize; +} + +TInt CMIDEnv::NumColors() +{ + TDisplayMode mode = DisplayMode(); + return TDisplayModeUtils::NumDisplayModeColors(mode); +} + +TDisplayMode CMIDEnv::DisplayMode() +{ + MMIDGraphicsFactory& factory = iToolkit->GraphicsFactory(); + return factory.DisplayMode(); +} + +void CMIDEnv::AddObserverL(MMIDEnvObserver& aObserver) +{ + ASSERT(iObservers.Find(&aObserver) == KErrNotFound); + // + User::LeaveIfError(iObservers.Append(&aObserver)); +} + +void CMIDEnv::RemoveObserver(MMIDEnvObserver& aObserver) +{ + TInt index = iObservers.Find(&aObserver); + if (index != KErrNotFound) + { + iObservers.Remove(index); + } +} + +void CMIDEnv::HandleSwitchOnL(TBool aSwitchOn) +{ + for (TInt i = iObservers.Count(); i--;) + iObservers[i]->HandleSwitchOnL(aSwitchOn); +} + +void CMIDEnv::HandleForegroundL(TBool aForeground) +{ +#ifdef RD_JAVA_NGA_ENABLED + if (aForeground) + { + iFullOrPartialFg = ETrue; + } +#endif // RD_JAVA_NGA_ENABLED + + for (TInt i = iObservers.Count(); i--;) + { + iObservers[i]->HandleForegroundL(aForeground); + } + if (aForeground && iToolkit && iToolkit->Utils()) + { + iToolkit->Utils()->HandleForegroundL(aForeground); + } +} + +void CMIDEnv::HandleResourceChangeL(TInt aType) +{ + for (TInt i = iObservers.Count(); i--;) + { + iObservers[i]->HandleResourceChangeL(aType); + } + if (iToolkit && iToolkit->Utils()) + { + iToolkit->Utils()->HandleResourceChangedL(); + } +} + +#ifdef RD_JAVA_NGA_ENABLED +void CMIDEnv::HandleFullOrPartialForegroundL(TBool aForeground) +{ + iFullOrPartialFg = aForeground; + for (TInt i = iObservers.Count(); i--;) + { + iObservers[i]->HandleFullOrPartialForegroundL(aForeground); + } +} + +void CMIDEnv::HandleFreeGraphicsMemory() +{ + for (TInt i = iObservers.Count(); i--;) + { + iObservers[i]->HandleFreeGraphicsMemory(); + } +} + +TBool CMIDEnv::HasFullOrPartialForeground() const +{ + return iFullOrPartialFg; +} +#endif //RD_JAVA_NGA_ENABLED + +TInt CMIDEnv::MidletAttribute(const TDesC& aAttributeName, TPtrC& aAttributeValue) +{ + return iToolkit->MidletAttribute(aAttributeName,aAttributeValue); +} + +TBool CMIDEnv::MidletAttributeIsSetToVal(const TDesC& aAttributeName, + const TDesC& aAttributeValue) +{ + TPtrC attributeValue; + + if (MidletAttribute(aAttributeName, attributeValue) == KErrNone && + attributeValue.CompareF(aAttributeValue) == 0) + { + return ETrue; + } + else + { + return EFalse; + } +} + +TBool CMIDEnv::MidletAttributeContainsVal(const TDesC& aAttributeName, + const TDesC& aAttributeValue) +{ + TPtrC attributeValue; + + if (MidletAttribute(aAttributeName, attributeValue) == KErrNone) + { + TInt startIdx = attributeValue.FindF(aAttributeValue); + if (startIdx != KErrNotFound) + { + if (aAttributeName.FindF(LcduiMidletAttributes::KAttribUIEnhancement) == KErrNotFound) + { + // If there is a preceding character before the value substring, it must be a comma + if (startIdx == 0 || attributeValue[ startIdx - 1 ] == KCharComma) + { + // Check what comes after the found value substring. + TInt endIdx = startIdx + aAttributeValue.Length(); + if (endIdx < attributeValue.Length()) + { + // only comma is ok + if (attributeValue[ endIdx ] == KCharComma) + { + return ETrue; + } + } + } + else // the found substring was right at the end of attributeValue string + { + return ETrue; + } + } + else // it is "Nokia-UI-Enhancement" - it is enough just to identify the substring in list of values + { + return ETrue; + } + } + } + + return EFalse; +} + +void CMIDEnv::SetCanvasAssumedSize(const TSize& aSize) +{ + iCanvasAssumedSize = aSize; +} +CFbsBitmap* CMIDEnv::ReserveCanvasFrameBufferL(MMIDCanvas& aCanvas, const TSize& aSz) +{ + CMIDEnv::TMutexAutoLock lock(&iCanvasData.iLock); + if (!aCanvas.IsGameCanvas()) + { + if (!iCanvasData.iFrameBuffer) + { + iCanvasData.iFrameBuffer = CreateCanvasFrameBufferL(aCanvas, ETrue, aSz); + } + iCanvasData.iRefCount++; + return iCanvasData.iFrameBuffer; + } + return CreateCanvasFrameBufferL(aCanvas, ETrue, aSz); +} + +void CMIDEnv::ReleaseCanvasFrameBuffer(MMIDCanvas& aCanvas, CFbsBitmap*& aFrameBuffer) +{ + CMIDEnv::TMutexAutoLock lock(&iCanvasData.iLock); + if (!aCanvas.IsGameCanvas()) + { + if (iCanvasData.iFrameBuffer) + { + iCanvasData.iRefCount--; + if (iCanvasData.iRefCount <= 0) + { + iCanvasData.Reset(); + } + } + } + else + { + delete aFrameBuffer; + aFrameBuffer = NULL; + } +} + +CFbsBitmap* CMIDEnv::CreateCanvasFrameBufferL( + MMIDCanvas& /* aCanvas */, TBool aWsBitmap, const TSize& aSz) +{ + CFbsBitmap* bitmap = new(ELeave) CFbsBitmap; + CleanupStack::PushL(bitmap); + TInt err = KErrGeneral; + err = bitmap->CreateHardwareBitmap(aSz, DisplayMode(), MidletUid()); + if (KErrNone != err) + { + // Failed to create hardware bitmap. Fall back to normal software only bitmaps + User::LeaveIfError(bitmap->Create(aSz, DisplayMode())); + } + if (!aWsBitmap) + { + CleanupStack::Pop(); + return bitmap; + } + CWsBitmap* wsBitmap = + new(ELeave) CWsBitmap(CCoeEnv::Static()->WsSession()); + err = wsBitmap->Duplicate(bitmap->Handle()); + if (KErrNone != err) + { + delete wsBitmap; + User::Leave(err); + } + CleanupStack::PopAndDestroy(bitmap); + return wsBitmap; +} + +TBool CMIDEnv::CanvasHasBackground(const MMIDCanvas& /* aCanvas */) const +{ + return iCanvasData.iHasBackground; +} + +#ifdef RD_JAVA_NGA_ENABLED +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +TBool CMIDEnv::IsHardwareAcceleratedL(MMIDEnv::THardwareType aHardwareType) +{ + ASSERT(iHardwareStatus); + return (iHardwareStatus & aHardwareType); +} + +// --------------------------------------------------------------------------- +// Checks from OpenGL ES API, if it is HW accelerated +// --------------------------------------------------------------------------- +// +TInt CMIDEnv::InitHardwareStatusL() +{ + iHardwareStatus = 1; + + EGLDisplay eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY); + eglInitialize(eglDisplay, NULL, NULL); + + EGLConfig config; + EGLint numOfConfigs = 0; + // Choose suitable display config + const EGLint attribs[] = + { + EGL_SURFACE_TYPE, EGL_PBUFFER_BIT, + EGL_BUFFER_SIZE, 32, + EGL_DEPTH_SIZE, 16, + EGL_NONE + }; + eglChooseConfig(eglDisplay, attribs, &config, 1, &numOfConfigs); + // Create a surface + const EGLint pBuffAttribs[] = + { + EGL_WIDTH, 1, + EGL_HEIGHT, 1, + EGL_NONE + }; + EGLSurface surface = eglCreatePbufferSurface(eglDisplay, config, pBuffAttribs); + // Create a context into this thread. + EGLContext context = eglCreateContext(eglDisplay, config, EGL_NO_CONTEXT, NULL); + // Try to bind surface to context + if (context != EGL_NO_CONTEXT && surface != EGL_NO_SURFACE && + eglMakeCurrent(eglDisplay, surface, surface, context)) + { + if (strstr((const char *)glGetString(GL_RENDERER), "HW")) + { + iHardwareStatus |= MMIDEnv::EHardware3D; + } + eglMakeCurrent(eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); + } + + if (context != EGL_NO_CONTEXT) + { + eglDestroyContext(eglDisplay, context); + } + + if (surface != EGL_NO_SURFACE) + { + eglDestroySurface(eglDisplay, surface); + } + + eglTerminate(eglDisplay); + + return iHardwareStatus; +} + +#endif // RD_JAVA_NGA_ENABLED + +void CMIDEnv::MappingDataForKey(TKeyEvent& aEvent, TEventCode aType) +{ + iToolkit->Utils()->MappingDataForKey(aEvent, aType); +} + +void CMIDEnv::SetLastKeyEvent(const TKeyEvent& aEvent) +{ + iToolkit->Utils()->SetLastKeyEvent(aEvent); +} + + +// --------------------------------------------------------------------------- +// CMIDEnv::ToLcduiObserver +// Gets an instance of ToLcduiObserver. +// --------------------------------------------------------------------------- +// +MMIDToLcduiObserver& CMIDEnv::ToLcduiObserver() +{ + return *iToLcduiObserver; +} + +void CMIDEnv::DisplayableIsDestructed(const MMIDDisplayable* aDisplayable) +{ + // Inform CMIDToolkit about deleting of displayble. This is needed + // for prevereting of panic during changing to new Displayable + iToolkit->DisplayableIsDestructed(aDisplayable); +} + +const MMIDDisplayable* CMIDEnv::LastFullscreenDisplayable() const +{ + return iToolkit->LastFullscreenDisplayable(); +}