/*
* 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:
*
*/
#ifndef CMIDTOOLKIT_H
#define CMIDTOOLKIT_H
#include <mevents.h>
#include <coecntrl.h>
//
#include <Lcdglue.h>
#include "CMIDEnv.h"
#include "MIDUtils.h"
#include "lcdui.h"
#include "lcdgr.h"
//
class CApaWindowGroupName;
class CMIDToolkit;
class MMIDDisplayable;
/**
Utility class providing access to the MIDlet suite attributes.
*/
class CMIDletSuite : public CBase
{
public:
CMIDletSuite();
~CMIDletSuite();
void SetAttributesL(RPointerArray<HBufC>& aAttributes);
TInt GetAttribute(const TDesC& aName, TPtrC& aValue);
private:
RPointerArray<HBufC> iAttributes;
};
/**
*
* Main class in the framework, one per MIDlet
*
* CMIDToolkit isA java event source and as such has an extremely complicated lifecycle with
* several states:
*
* The source is constructed via a mechanism that ensures the first three phases of construction
* succeed fully or the object is fully destroyed. This is handled by the New() static method in
* CJavaEventSource<CMIDToolkit>.
*
* CMIDToolkit() // PHASE 1
* ConstructL() // PHASE 2
* SvrConstructL() // PHASE 3
*
* FinalizeSvr() // PHASE 3
* FinalizeJni() // PHASE 2
* ~CMIDToolkit() // PHASE 1
*
*/
class CMIDToolkit : public CJavaEventSource<CMIDToolkit>, public MMIDObserver
{
public:
TInt PostDisplayEvent(TEventType aEvent);
TInt PostDisplayableEvent(MMIDComponent& aDisplayable, TEventType aEvent, TInt aParam0, TInt aParam1);
TInt PostItemEvent(MMIDComponent& aItem, TEventType aEvent, TInt aParam0, TInt aParam1, TInt aParam2);
TInt PostCanvasGraphicsItemPainterEvent(MMIDComponent& aCanvasGraphicsItemPainter,
TEventType aEvent, TInt aParam0, TInt aParam1);
inline MMIDDisplayable* Current();
TPtrC MidletName() const;
inline TUid MidletUid() const;
inline TPtrC MidletHome() const;
/**
* Inform CMIDToolkit about deleting of object implementing MMIDDisplayable.
*
* @param displayable deleting displayble
* @since Java 2.0
*/
inline void DisplayableIsDestructed(const MMIDDisplayable* aDisplayable);
TInt MidletAttribute(const TDesC& aAttributeName, TPtrC& aAttributeValue);
public:
/**
* Other server side methods
*/
static void InvokeSvrConstructL(CMIDToolkit* aToolkit,const TDesC* aName);
void SetCurrentL(MMIDDisplayable* aDisplayable);
void ClearDisplayable();
TBool PostSerialEvent(jobject aRunnable);
void DisposeObject(MMIDComponent* aObject);
// Returns pointer to last fullscreen displayble.
inline const MMIDDisplayable* LastFullscreenDisplayable() const;
//
// Activate event sources
//
void ActivateL();
TInt RegisterComponentL(MMIDComponent* aComponent, TJavaPeer aPeer);
public:
// Factory
static TInt New
(
JNIEnv& aJni,
jobject aPeer,
TJavaEventServer aServer,
const TDesC& aAppName,
TInt aAppUid,
const TDesC& aAppHome,
RPointerArray<HBufC>* aAttributes // may be NULL
);
/**
* PHASE 1 Constructor.
*/
CMIDToolkit();
/**
* PHASE 1 Destructor
*/
~CMIDToolkit();
/**
* PHASE 2 Constructor
*/
void ConstructL(JNIEnv& aJni,
jobject aPeer,
TJavaEventServer aServer,
const TDesC& aAppName,
TInt aAppUid,
const TDesC& aHomeDir,
RPointerArray<HBufC>* aAttributes // may be NULL
);
inline MMIDComponentFactory* CMIDToolkit::ComponentFactory() const;
inline MMIDUtils* Utils() const;
inline MMIDEnv* Env() const;
inline CApaWindowGroupName* WgName() const; // _APIEXT_SASF_
public:
inline MMIDGraphicsFactory& GraphicsFactory() const;
inline static TJavaPeer ComponentPeer(MMIDComponent& aComponent);
void BringToForeground();
void SendToBackground();
public:
/*
* From MMIDObserver
*/
void HandleExitL();
void HandleForegroundL(TBool aForeground);
void HandleSwitchOnEventL();
void HandleResourceChangeL(TInt aType);
#ifdef RD_JAVA_NGA_ENABLED
void HandleFullOrPartialForegroundL(TBool aFullOrPartialFg);
void HandleFreeGraphicsMemory();
#endif
private:
/**
* Resets user inactivity timers
*/
void ResetInactivityTimeL();
static TInt CreateToolkitL
(
JNIEnv& aJni,
jobject aPeer,
TJavaEventServer aServer,
const TDesC& aAppName,
TInt aAppUid,
const TDesC& aAppHome,
RPointerArray<HBufC>* aAttributes // may be NULL
);
/**
* Phase 3 constructor.
*/
void SvrConstructL(const TDesC& aName);
void CreateTaskListEntryL(const TDesC& aName);
void SetTaskListEntry(TBool);
/**
* Phase 3 destructor
*/
void FinalizeSvr();
/**
* Phase 2 destructor
*/
void FinalizeJni(JNIEnv& aJni);
/**
* Cleanup an object
*/
void DisposeEntry(TInt aIndex, TBool aPostEvent);
/**
* Set window group ordinal position.
*/
void SetOrdinalPosition(TInt aOrdinal);
/**
* Filter events - actually more of an on/off tap
*/
TBool CheckEvent(CJavaEventBase*);
void LoadLibrariesL();
/**
* If current displayable is canvas,
* returns pointer to it.
*
* @return pointer to the current canvas, if current displayable is canvas.
* NULL, if current displayable is not canvas.
*/
MMIDCanvas* GetCurrentCanvas() const;
public:
/*@ deprecated */
jmethodID iHandleNotifyMethod;
private:
jmethodID iHandleItemEvent;
jmethodID iHandleDisplayableEvent;
jmethodID iHandleDisplayEvent;
jmethodID iHandleCanavsGraphicsItemPainterEvent;
private:
enum {EGranularity=4};
private:
enum TPhase
{
ENone,
EPhase1,
EPhase2,
EPhase3
};
struct TObjectEntry
{
public:
TObjectEntry(MMIDComponent* aComponent);
union
{
MMIDComponent* iComponent;
TObjectEntry* iNextEntry;
};
TJavaPeer iDisposed;
};
private:
friend class CMIDFinalizeEvent;
/**
* Delete weak refs - called from CMIDDisposeEvent only..
*/
void FinalizeReferences(JNIEnv& aEnv);
void DestroyUi();
private:
TPhase iPhase;
TUid iAppUid;
HBufC* iHomeDir;
CMIDletSuite* iMidletSuite;
TObjectEntry* iFinalizeQueue; // finalization queue of weak ref entries
TInt iFinalizeCount;
RCriticalSection iFinalizeMutex;
private:
/**
* Server fields
*/
TObjectEntry* iDisposedQueue; // Disposed entry queue - pending finalization
TInt iDisposedCount;
CCoeEnv* iCoeEnv; // Not Owned.
MMIDDisplayable* iCurrentDisplayable; // Not Owned.
MMIDDisplayable* iOldFullScreenDisplayable; // Not Owned.
CApaWindowGroupName* iWgName;
CMIDEnv* iEnv;
RArray<TObjectEntry*> iObjects;
MMIDComponentFactory* iUiFactory;
MMIDUtils* iUtils;
RLibrary iGrLibrary;
MMIDGraphicsFactory* iGrFactory;
TBool iOpen;
TBool iMidletRequestedBg; // indicates if MIDlet itself has requested sending to background
TTime iSentToBgTime; // timestamp when MIDlet was sent to background
TBool mFirst;
};
/**
* Useful functions:
*/
inline void CleanupDisposePushL(MMIDComponent* aComponent);
inline void CleanupPopComponent(MMIDComponent* aComponent);
inline MMIDDisplayable* CMIDToolkit::Current()
{
return iCurrentDisplayable;
}
inline TUid CMIDToolkit::MidletUid() const
{
return iAppUid;
}
inline TPtrC CMIDToolkit::MidletHome() const
{
return *iHomeDir;
}
inline MMIDComponentFactory* CMIDToolkit::ComponentFactory() const
{
return iUiFactory;
}
inline MMIDUtils* CMIDToolkit::Utils() const
{
return iUtils;
}
inline MMIDEnv* CMIDToolkit::Env() const
{
return iEnv;
}
// --> _APIEXT_SASF_
inline CApaWindowGroupName* CMIDToolkit::WgName() const
{
return iWgName;
}
// <-- _APIEXT_SASF_
inline MMIDGraphicsFactory& CMIDToolkit::GraphicsFactory() const
{
return *iGrFactory;
}
inline TJavaPeer CMIDToolkit::ComponentPeer(MMIDComponent& aComponent)
{
return aComponent.iPeer;
}
inline void DisposeComponent(TAny* aPtr)
{
MMIDComponent* component = static_cast<MMIDComponent*>(aPtr);
component->Dispose();
}
inline void CleanupDisposePushL(MMIDComponent* aComponent)
{
CleanupStack::PushL(TCleanupItem(DisposeComponent, aComponent));
}
inline void CleanupPopComponent(MMIDComponent* aComponent)
{
CleanupStack::Pop(aComponent);
}
inline void CMIDToolkit::DisplayableIsDestructed(const MMIDDisplayable* aDisplayable)
{
// If this is set as iOldFullScreenDisplayable, we need set this to NULL.
if (aDisplayable == iOldFullScreenDisplayable)
{
iOldFullScreenDisplayable = NULL;
// We need to inform current Displayable about destroying
// old full screen Displayable.
if (iCurrentDisplayable)
{
iCurrentDisplayable->DisplayableBehindPopupIsDestroyed();
}
}
}
inline const MMIDDisplayable* CMIDToolkit::LastFullscreenDisplayable() const
{
return iOldFullScreenDisplayable;
}
#endif // CMIDTOOLKIT_H