/*

* Copyright (c) 1999 - 2003 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 <coecntrl.h>

#include <coeccntx.h>

#include <coecobs.h>

#include <apgwgnam.h>

#include <coemain.h>

#include <eikenv.h>

#include <eikappui.h>

#include <apgtask.h>

#include <bautils.h>

#include <s32stor.h>

#include <s32file.h>

#include <gfxtranseffect/gfxtranseffect.h>  // For transition effects

#include <akntranseffect.h>                                 // For transition effects

//

#include "lcdui.h"

#include "lcdgr.h"

#include "mevents.h"

#include "jutils.h"

#include "MIDUtils.h"

#include "CJavaEventServer.h"

#include "CMIDToolkit.h"

#include "CMIDEvent.h"

#include "CMIDBuffer.h"

#include "CMIDNotify.h"

#include <stdio.h>

#include "LcduiThread.h"

#include "coreuiavkonlcdui.h"

#include "coreuiappui.h"

#include "MMIDCanvasGraphicsItemPainter.h"

#include <jdebug.h>

#ifdef LCDUI_DEBUG_ON

#define LCDUI_DEBUG(msg) DEBUG(msg)

#define LCDUI_DEBUG_INT(msg, x) DEBUG_INT(msg, x)

#else

#define LCDUI_DEBUG(msg)

#define LCDUI_DEBUG_INT(msg, x)

#endif

/**

 * Macro controlling synthesis of AppArc foreground event when the

 * MIdlet requests that the Display be brought to the foreground.

 *

 * Some UI's may require this event, others may not.

 *

 * Generation of this event should be moved to the plugin.

 */

#define GENERATE_APPARC_FOREGROUND_EVENT 1

/**

 * Macro controlling whether the tasklist entry is cleared early in

 * CMIDToolkit::Close() or left in place until the window group is

 * destroyed (when the eikonenv is destroyed).

 *

 */

#define CLEAR_TASKLIST_IN_CLOSE 1

/**

 * Macro extracting the weak reference corresponding to a component.

 */

#define MIDJOBJECT(component)  ( reinterpret_cast<jobject>((component)->iPeer) )

/**

 * Graphics plugin library name.

 */

_LIT(KGrLibName,"lcdgr");

/**

 * Window group ordinal position (z-order) for sending to background.

 */

const TInt KWgOrdinalBackground = -1;

/**

 * Window group ordinal position (z-order) for bringing to foreground.

 */

const TInt KWgOrdinalForeground = 0;

/**

 * This timeout (microseconds) defines how long we prevent MIDlet from becoming

 * back to foregound after user has switched it to background.

 * Some MIDlets change the current displayable in hideNotify(), which (without this prevention)

 * would cause them to become back to foreground immediately.

 */

const TInt KChangingToBackgroundTimeout = 5000000;

/**

 * LCDGR graphics plugin factory function.

 */

typedef MMIDGraphicsFactory*(*TCreateGraphicsFactoryFunc)(RFs&, TDisplayMode);

/**

 * Exception safe reversion to previous displayable if CMIDToolkit::SetCurrentL fails.

 *

 */

class TRevertCurrent

{

public:

    TRevertCurrent(MMIDDisplayable*& aCurrentPointer)

            : iCurrentPointer(aCurrentPointer)

            , iPrevious(aCurrentPointer)

    {

    }

    static void Revert(TAny*);

private:

    MMIDDisplayable*& iCurrentPointer;

    MMIDDisplayable*  iPrevious;

};

/**

 * process entries on finalize queue.

 */

class CMIDFinalizeEvent : public CJavaEvent<CMIDToolkit>

{

private:

    void Dispatch(JNIEnv& aJni);

};

const static TInt KPayload = 16; // Number of weak references on queue before dispose event

/**

 * Register an MMIDComponent and its peer with the Toolkit.

 *

 *@return an object handle.

 */

TInt CMIDToolkit::RegisterComponentL(MMIDComponent* aComponent, TJavaPeer aPeer)

{

    ASSERT(aComponent);

    TObjectEntry* entry = new(ELeave) TObjectEntry(aComponent);

    CleanupStack::PushL(entry);

    User::LeaveIfError(iObjects.Append(entry));

    CleanupStack::Pop(entry);

    aComponent->iPeer = aPeer;

    return MIDHandle(aComponent);

}

/**

 * CONSTRUCTION PHASE 1 . Java side.

 */

CMIDToolkit::CMIDToolkit()

        : iPhase(EPhase1)

        , iOldFullScreenDisplayable(NULL), iObjects(EGranularity), iSentToBgTime(0), mFirst(ETrue)

{

    LCDUI_DEBUG_INT("CMIDToolkit::CMIDToolkit(%d) CONSTRUCTION PHASE 1", (TInt)this);

    iFinalizeMutex.CreateLocal();

}

/**

 * DESTRUCTION PHASE 1 . Java side

 */

CMIDToolkit::~CMIDToolkit()

{

    LCDUI_DEBUG_INT("CMIDToolkit::~CMIDToolkit(%d): DESTRUCTION PHASE 1 <BEGIN>", (TInt)this);

    ASSERT(iPhase == EPhase1);

    iFinalizeMutex.Close();

    iObjects.Close();

    //

    // We cannot delete any server side objects in the

    // destructor since it runs Java side. Therefore if

    // any of the following invariants fail, we have

    // leaked or failed to zero the pointer.

    //

    ASSERT(0    == iObjects.Count());

    ASSERT(NULL == iDisposedQueue);

    ASSERT(0    == iDisposedCount);

    ASSERT(NULL == iFinalizeQueue);

    ASSERT(NULL == iFinalizeCount);

    // Not owned but worth checking we clean everything.

    ASSERT(NULL == iCoeEnv);

    // Owned - if these are non-null we leaked.

    ASSERT(NULL == iWgName);

    ASSERT(NULL == iHomeDir);

    ASSERT(NULL == iEnv);

    ASSERT(NULL == iMidletSuite);

    ASSERT(NULL == iUtils);

    ASSERT(NULL == iUiFactory);

    ASSERT(NULL == iGrFactory);

    ASSERT(0    == iGrLibrary.Handle());        // Did we unload the gr library

    ASSERT(NULL == iCurrentDisplayable);        // Did we clean up correctly

    LCDUI_DEBUG_INT("CMIDToolkit::~CMIDToolkit(%d): DESTRUCTION PHASE 1 <END>", (TInt)this);

}

void CMIDToolkit::HandleExitL()

{

    PostDisplayEvent(EExit);

}

void CMIDToolkit::HandleForegroundL(TBool aForeground)

{

    if (aForeground)

    {

        // reset flag

        iMidletRequestedBg = EFalse;

        iSentToBgTime = 0;

        LCDUI_DEBUG("**FE**");

    }

    else

    {

        iSentToBgTime.HomeTime();

        LCDUI_DEBUG("**BE**");

    }

    iEnv->HandleForegroundL(aForeground);

    PostDisplayEvent(aForeground?EForeground:EBackground);

}

void CMIDToolkit::HandleResourceChangeL(TInt aType)

{

    iEnv->HandleResourceChangeL(aType);

}

void CMIDToolkit::HandleSwitchOnEventL()

{

    iEnv->HandleSwitchOnL(ETrue);

}

/**

 * CONSTRUCTION PHASE 2.

 * Java Side.

 */

void CMIDToolkit::ConstructL

(

    JNIEnv&             aJni,

    jobject             aPeer,

    TJavaEventServer    aServer,

    const TDesC&        aAppName,

    TInt                aAppUid,

    const TDesC&        aAppHome,

    RPointerArray<HBufC>* aAttributes

)

{

    LCDUI_DEBUG_INT("CMIDToolkit::ConstructL(%x) CONSTRUCTION PHASE 2 ", (TInt)this);

    ASSERT(iPhase == EPhase1);

    iPhase = EPhase2;

    CJavaEventSourceBase::ConstructL(aJni,aPeer,aServer);

    jclass clz = aJni.GetObjectClass(aPeer);

    iHandleItemEvent = aJni.GetMethodID(clz, "handleItemEvent", "(Ljavax/microedition/lcdui/Item;IIII)V");

    iHandleDisplayableEvent = aJni.GetMethodID(clz, "handleDisplayableEvent", "(Ljavax/microedition/lcdui/Displayable;IIII)V");

    iHandleDisplayEvent = aJni.GetMethodID(clz, "handleDisplayEvent", "(Ljavax/microedition/lcdui/Toolkit;IIII)V");

    iHandleNotifyMethod = aJni.GetMethodID(clz, "handleAsyncEvent", "(Ljava/lang/Object;I)V");

    iHandleCanavsGraphicsItemPainterEvent = aJni.GetMethodID(

                                                clz,

                                                "handleCanvasGraphicsItemPainterEvent",

                                                "(Ljavax/microedition/lcdui/CanvasGraphicsItemPainter;IIII)V");

    aJni.DeleteLocalRef(clz);

    if (0 == iHandleNotifyMethod       ||

            0 == iHandleDisplayEvent       ||

            0 == iHandleDisplayableEvent   ||

            0 == iHandleItemEvent

       )

    {

        User::Leave(KErrGeneral);

    }

    iHomeDir=aAppHome.AllocL();

    iAppUid=TUid::Uid(aAppUid);

    iMidletSuite = new(ELeave) CMIDletSuite;

    if (aAttributes)

    {

        iMidletSuite->SetAttributesL(*aAttributes);

    }

    CMIDToolkit* toolkit = this;

    const TDesC* appName = &aAppName;

    TInt err = ExecuteTrap(&CMIDToolkit::InvokeSvrConstructL, toolkit, appName);

    User::LeaveIfError(err);

}

void CMIDToolkit::InvokeSvrConstructL(CMIDToolkit* aToolkit, const TDesC* aName)

{

    User::LeaveIfError(RLcdui::Get()->CreateAppUi());

    aToolkit->SvrConstructL(*aName);

}

/**

 * CONSTRUCTION PHASE 3.

 * Server Side.

 */

void CMIDToolkit::SvrConstructL(const TDesC& aAppName)

{

    LCDUI_DEBUG_INT("CMIDToolkit::SvrConstructL(%x) CONSTRUCTION PHASE 3", (TInt)this);

    ASSERT(iPhase == EPhase2);

    iPhase = EPhase3;   // fully constructed

    //

    // This is the first method called server side, so the first place

    // we can safely obtain these pointers.

    //

    iCoeEnv = CCoeEnv::Static();

    iEnv = new(ELeave) CMIDEnv(this, TSize());

    iEnv->ConstructL();

    CreateTaskListEntryL(aAppName);

    SetTaskListEntry(EFalse);

    //

    //

    //

    LoadLibrariesL();

}

void CMIDToolkit::CreateTaskListEntryL(const TDesC& aAppName)

{

    ASSERT(NULL == iWgName);

    iWgName = java::ui::CoreUiAvkonLcdui::getInstance().getWindowGroupName();

    iWgName->SetRespondsToSwitchFilesEvent(EFalse);

    iWgName->SetCaptionL(aAppName);

}

void CMIDToolkit::LoadLibrariesL()

{

    ASSERT(NULL == iGrFactory);

    ASSERT(NULL == iUiFactory);

    RFs& fs = iCoeEnv->FsSession();

    TDisplayMode screenMode=iCoeEnv->ScreenDevice()->DisplayMode();

#ifdef RD_JAVA_S60_RELEASE_9_2

    if (screenMode == EColor16MAP)

    {

        screenMode = EColor16MA;

    }

#endif

    //

    // Load the GR dll

    //

    User::LeaveIfError(iGrLibrary.Load(KGrLibName));

    TCreateGraphicsFactoryFunc CreateGraphicsFactoryL;

    CreateGraphicsFactoryL = (TCreateGraphicsFactoryFunc)iGrLibrary.Lookup(1);

    if (!CreateGraphicsFactoryL)

    {

        User::Leave(KErrBadLibraryEntryPoint);

    }

    iGrFactory = (*CreateGraphicsFactoryL)(fs, screenMode);

    MLcduiPlugin* plugin = RLcdui::Get()->Plugin();

    if (!plugin)

    {

        User::Leave(KErrGeneral);

    }

    iUiFactory = plugin->CreateComponentFactoryL();

    iUiFactory->ConstructL(*iEnv);

    iUtils = iUiFactory->CreateUtilsL();

    iEnv->SetUtils(iUtils);

}

//

// Enables events

//

void CMIDToolkit::ActivateL()

{

    iOpen=ETrue;

    SetTaskListEntry(ETrue);

    RLcdui::Get()->Plugin()->SetObserver(this);

    iCoeEnv->RootWin().EnableReceiptOfFocus(ETrue);

}

void CMIDToolkit::SetTaskListEntry(TBool aVisible)

{

    iWgName->SetRespondsToShutdownEvent(aVisible);

    iWgName->SetHidden(!aVisible);

    iWgName->SetAppUid(iAppUid);

    iWgName->SetWindowGroupName(iCoeEnv->RootWin());

}

TPtrC CMIDToolkit::MidletName() const

{

    return iWgName->Caption();

}

void CMIDToolkit::SetCurrentL(MMIDDisplayable* aDisplayable)

{

    MMIDDisplayable* newDisplayable = aDisplayable;

    MMIDDisplayable* oldDisplayable = iCurrentDisplayable;

    // Prepare switch

    TRevertCurrent revert(iCurrentDisplayable);

    CleanupStack::PushL(TCleanupItem(TRevertCurrent::Revert, &revert));

    ASSERT(newDisplayable != oldDisplayable);

    if (NULL == newDisplayable)

    {

        ASSERT(oldDisplayable);

        ASSERT(oldDisplayable->Component()->Type() == MMIDComponent::EAlert);

    }

    // Set it, revert will rollback if required.

    iCurrentDisplayable = newDisplayable;

    // Activate new displayable first. If this leaves the java toolkit

    // will have to cope with an unwanted pending switch event.

    if (newDisplayable)

    {

        newDisplayable->HandleCurrentL(ETrue);

    }

    // When new Displayable is EAlert and old Displayable is ECanvas then

    // variable iOldFullScreenDisplayable will have the value ECanvas.

    // This applies for Canvas in Normal mode and in Full Screen mode.

    // Deactivate old displayable - if this fails the

    // displayable is itself responsible for cleanup.

    // Deactivate also old Full Screen displayable.

    if (oldDisplayable)

    {

        TInt ignore1;

        TRAP(ignore1, oldDisplayable->HandleCurrentL(EFalse));

        MMIDComponent::TType newType = newDisplayable->Component()->Type();

        if ((newType == MMIDComponent::EAlert || (newType == MMIDComponent::ETextBox &&

                newDisplayable->IsPopupTextBox())))

        {

            if (!iOldFullScreenDisplayable)

            {

                iOldFullScreenDisplayable = oldDisplayable;

            }

        }

        else

        {

            if (newDisplayable == iOldFullScreenDisplayable)

            {

                iOldFullScreenDisplayable = NULL;

            }

            else

            {

                if (iOldFullScreenDisplayable)

                {

                    TRAP(ignore1,

                         iOldFullScreenDisplayable->HandleCurrentL(EFalse));

                    iOldFullScreenDisplayable = NULL;

                }

            }

        }

        MMIDComponent::TType oldType = oldDisplayable->Component()->Type();

        if (newType == MMIDComponent::ECanvas && newType == oldType)

        {

            // When old and new displayable type is canvas during

            // deactivation of old displayable osk is set to background

            // and no pointer events goes to new displayable.

            // Change OSK background state to false

            newDisplayable->ChangeOSKBackgroundState(EFalse);

        }

    }

    CleanupStack::Pop();    // revert

}

void CMIDToolkit::BringToForeground()

{

    LCDUI_DEBUG("**RF**");

    // Block the foreground granting to MIDlet immediately after user has switched

    // MIDlet to background. If the background was requested by the MIDlet,

    // the foreground request made by MIDlet should not be prevented.

    TTime now;

    now.HomeTime();

    TTimeIntervalMicroSeconds elapsedTime = now.MicroSecondsFrom(iSentToBgTime);

    if (elapsedTime > TTimeIntervalMicroSeconds(KChangingToBackgroundTimeout) ||

            iMidletRequestedBg)

    {

        if (mFirst)

        {

            TRAP_IGNORE(HandleForegroundL(ETrue));

        }

        SetOrdinalPosition(KWgOrdinalForeground);

        if (mFirst)

        {

            java::ui::CoreUiAvkonAppUi* appUi = java::ui::CoreUiAvkonLcdui::getInstance().getJavaUiAppUi();

            if (appUi && appUi->hasStartScreen())

            {

                MMIDComponent* content = iCurrentDisplayable ? iCurrentDisplayable->Component() : NULL;

                if (!content || content->Type() != MMIDComponent::ECanvas)

                {

                    if (iCurrentDisplayable)

                        iCurrentDisplayable->DrawNow();

                    appUi->stopStartScreen();

                }

            }

            mFirst = EFalse;

        }

    }

}