/*

* 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