/*******************************************************************************

 * Copyright (c) 2009, 2010 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     Nokia Corporation - initial implementation

 *******************************************************************************/

#include <eikenv.h>

#include <apgwgnam.h> // For CApaWindowGroupName

#include <coemain.h>

#include <eikappui.h>

#include <w32std.h>

#include <avkon.hrh>

#include <QVariant>

#include <AknDef.h>

#include <apgtask.h>

#include <hal.h>

#include <org_eclipse_swt_internal_qt_OS.h>

#include "eventcallback.h"

#include "swts60.h"

#include "autorelease.h"

using namespace Java::eSWT;

// Name of the UI thread.

_LIT(KSwtUiThreadName, "SwtQtUiThread");

// Name of the support thread.

_LIT(KSwtSupportThreadName, "SwtQtSupportThread");

// Name of the shared library

_LIT(KSwtDllName, "eswtqt.dll");

// Stack size for the UI thread, 0x14000 = 80kB

const TInt KSwtUiThreadStackSize = 0x14000;

// Stack size for the support thread, 0x1F40 = 8kB

const TInt KSwtSupportThreadStackSize = 0x1F40;

static const char* const EVENT_FILTER = "swt_event_filter";

typedef struct

    {

    JavaVM* vm;

    jint uid;

    jobject runner;

    TRequestStatus initStatus;

    TThreadId initThreadId;

    TThreadId uiThreadId;

    TBool doFreeTLSInCleanupUIThread;

    }

SwtTlsData;

inline static void freeTLSData(SwtTlsData*& aData)

    {

    Dll::SetTls(NULL);

    delete aData;

    aData = NULL;

    }

TUid SwtQtS60MainApplication::AppDllUid() const

    {

    SwtTlsData* data = reinterpret_cast<SwtTlsData*>(Dll::Tls());

    TUid uid;

    uid.iUid = static_cast<TInt>(data ? data->uid : 0);

    return uid;

    }

int SymbianUtils::startUI(JNIEnv* aJniEnv, jobject aRunner, jint aUid)

    {

    // Get a VM pointer using the current thread context

    JavaVM* javaVM = NULL;

    jint getVMStatus = aJniEnv->GetJavaVM(&javaVM);

    if(getVMStatus < 0) return KErrNoMemory;

    jobject globalRef = aJniEnv->NewGlobalRef(aRunner);

    if(!globalRef) return KErrNoMemory;

    // in the UI thread

    SwtTlsData* data = new (std::nothrow) SwtTlsData();

    if(!data) return KErrNoMemory;

    data->vm = javaVM;

    data->uid = aUid;

    data->runner = globalRef;

    data->initStatus = KRequestPending;

    RThread thread;

    data->initThreadId = thread.Id();

    // Create a new thread that will be the UI thread

    TName uiThreadName(KSwtUiThreadName);

    RThread uiThread;

    TInt createStatus = uiThread.Create( uiThreadName, SymbianUtils::uiThreadEntryPoint,

            KSwtUiThreadStackSize, NULL, reinterpret_cast<TAny*>(data) );

    data->uiThreadId = uiThread.Id();

    if(createStatus != KErrNone)

        {

        delete data;

        return createStatus;

        }

    // status

    uiThread.Resume();

    User::WaitForRequest(data->initStatus);

    // Launch the support thread

    if(data->initStatus == KErrNone)

        {

        startSupportThread(reinterpret_cast<TAny*>(data));

        }

    // Return the thread initialization status

    }

int SymbianUtils::initUiThread(JNIEnv* aJniEnv, const TInt& aUid)

    {

    TBool isUiThread = ETrue;

    SwtTlsData* data = reinterpret_cast<SwtTlsData*>(Dll::Tls());

    if(!data) isUiThread = EFalse;

    // If this is already initialized as a UI thread by startUI the do nothing

    if(isUiThread)

        {

        return KErrNone;

        }

    data = new (std::nothrow) SwtTlsData();

    if(!data) return KErrNoMemory;

    data->doFreeTLSInCleanupUIThread = ETrue;

    Dll::SetTls(data);

    // This is the UI thread now, store its id

    RThread uiThread;

    data->uiThreadId = uiThread.Id();

    // Get a VM pointer using the current thread context

    JavaVM* javaVM = NULL;

    jint getVMStatus = aJniEnv->GetJavaVM(&javaVM);

    if(getVMStatus < 0) return KErrNoMemory;

    data->vm = javaVM;

    // Store the MIDlet uid we got as a parameter

    data->uid = aUid;

    // Launch the support thread

    startSupportThread(reinterpret_cast<TAny*>(data));

    return KErrNone;

    }

void SymbianUtils::cleanupUiThread()

    {

    SwtTlsData* data = reinterpret_cast<SwtTlsData*>(Dll::Tls());

    if(!data) return;

    if(data->doFreeTLSInCleanupUIThread)

        {

        freeTLSData(data);

        }

    }

void SymbianUtils::setAppName(JNIEnv* aJniEnv, jstring aName)

    {

    // Convert name from jstring to Symbian descriptor

    HBufC16* buffer = NULL;

    if(aName != NULL)

        {

        jboolean isCopy;

        const jchar* javaChars = aJniEnv->GetStringChars(aName, &isCopy);

        if (javaChars)

            {

            AutoReleaseStringChars cleaner(aJniEnv, aName, javaChars);

            jsize length = aJniEnv->GetStringLength(aName);

            TRAPD(err, buffer = HBufC16::NewL(length));

            if (err == KErrNone)

                {

                 TText16* ptr =const_cast<TText16*> (buffer->Des().Ptr());

                 memcpy(ptr, javaChars, length * sizeof(jchar));

                 buffer->Des().SetLength(length);

                }

            else

                {

                throw std::bad_alloc();

                }

            }

        else

            {

            throw std::bad_alloc();

            }

        }

    // Set the name to the window group

    CCoeEnv* coe = CCoeEnv::Static();

    CApaWindowGroupName* wgn = NULL;

    TRAPD( err, wgn = CApaWindowGroupName::NewL(coe->WsSession()));

    if(err == KErrNone)

        {

        SwtTlsData* data = reinterpret_cast<SwtTlsData*>(Dll::Tls());

        wgn->SetAppUid(TUid::Uid(static_cast<TInt>(data->uid)));

        TRAP_IGNORE(wgn->SetCaptionL(*buffer));

        wgn->SetWindowGroupName(coe->RootWin());

        delete wgn;

        }

    delete buffer;

    }

bool SymbianUtils::eventFilter(QObject* object, const TWsEvent* aEvent)

{

    int swtEventType = -1;

    switch (aEvent->Type())

    {

        swtEventType = org_eclipse_swt_internal_qt_OS_QSWTEVENT_SYSTEMSHUTDOWN;

        break;

            {

                {

                }

            }

    default:

        break;

    }

}

bool SymbianUtils::eventFilter(QObject* object, const TInt aSymbianType, TInt aSwtType)

    {

    if(aSymbianType > -1)

        {

        switch (aSymbianType)

           {

           case KEikDynamicLayoutVariantSwitch:

               aSwtType = org_eclipse_swt_internal_qt_OS_QSWTEVENT_RESOURCECHANGE;

               break;

           default:

               break;

           }

        }

    if (aSwtType > -1)

        {

        if (data.isValid())

            {

            EventCallback* filter = reinterpret_cast<EventCallback*> (data.toInt());

            if (filter)

                {

                return filter->eventFilter(object, 0, aSwtType);

                }

            }

        }

    return false;

    }

TInt SymbianUtils::GetScreenDeviceNumber()

    {

    return CCoeEnv::Static()->ScreenDevice()->GetScreenNumber();

    }

TInt SymbianUtils::GetColorDepth()

    {

    return TDisplayModeUtils::NumDisplayModeBitsPerPixel(

            CCoeEnv::Static()->ScreenDevice()->DisplayMode());

    }

TInt SymbianUtils::GetHwInputs()

    {

    TInt mask;

    HAL::Get(HALData::EKeyboard, mask);

    return mask;

    }

CApaApplication* SymbianUtils::NewApplication()

    {

    return new SwtQtS60MainApplication;

    }

        TThreadId aInitThreadId, TRequestStatus* aStatusPtr)

    {

    RThread initThread;

    TInt openStatus = initThread.Open(aInitThreadId);

    __ASSERT_DEBUG(openStatus == KErrNone, User::Panic(KSwtDllName, 0));

    if(openStatus == KErrNone)

        {

        initThread.RequestComplete(aStatusPtr, aStatus);

        initThread.Close();

        }

    }

TInt SymbianUtils::uiThreadEntryPoint(TAny* aTlsData)

    {

    // Take ownership the the TLS data

    SwtTlsData* data = reinterpret_cast<SwtTlsData*>(aTlsData);

    Dll::SetTls(aTlsData);

    data->doFreeTLSInCleanupUIThread = EFalse;

    User::SetCritical(User::EProcessCritical);

    // Create a CleanupStack

    CTrapCleanup* cleanup = CTrapCleanup::New();

    if(!cleanup)

        {

        notifyThreadInitStatus(KErrNoMemory, data->initThreadId, &data->initStatus);

        freeTLSData(data);

        return KErrNoMemory;

        }

    JNIEnv* env = NULL;

    void* args = NULL;

    if(attachStatus < 0)

        {

        notifyThreadInitStatus(KErrNoMemory, data->initThreadId, &data->initStatus);

        freeTLSData(data);

        delete cleanup;

        cleanup = NULL;

        return KErrNoMemory;

        }

    // Obtain methodID of run() of the Java callback object

    jclass runnerClass = env->GetObjectClass(data->runner);

    jmethodID mid = NULL;

    if(runnerClass) mid = env->GetMethodID(runnerClass, "run", "()V");

    // Check if something failed

    if(!mid)

        {

        notifyThreadInitStatus(KErrNoMemory, data->initThreadId, &data->initStatus);

        TRAP_IGNORE(data->vm->DetachCurrentThread());

        freeTLSData(data);

        delete cleanup;

        cleanup = NULL;

        return KErrNoMemory;

        }

    // Notify the waiting thread that initialization has completed successfully

    notifyThreadInitStatus(KErrNone, data->initThreadId, &data->initStatus);

    // Call run() of the Java callback object. Inside this call the UI event

    TRAPD(err, env->CallVoidMethod(data->runner, mid));

    if(err != KErrNone)

        {

        // class library that has failed. This is a fatal error and the process

        // should die.

        User::Panic(KSwtUiThreadName, 0);

        }

    // Remove the reference to the runner Java object

    TRAP_IGNORE(env->DeleteGlobalRef(data->runner));

    data->runner = NULL;

    // Detach the UI thread from the VM

    TRAP_IGNORE(data->vm->DetachCurrentThread());

    freeTLSData(data);

    delete cleanup;

    cleanup = NULL;

    return KErrNone;

    }

/*

 * always have a top-level trap also in this thread to avoid panics such as

 */

TInt SymbianUtils::supportThreadEntryPoint(TAny* aParams)

    {

    CTrapCleanup* cleanup = CTrapCleanup::New();

    int retVal = 0;

    TRAP_IGNORE(retVal = trappedSupportThreadEntryPoint(aParams));

    delete cleanup;

    cleanup = NULL;

    return retVal;

    }

TInt SymbianUtils::trappedSupportThreadEntryPoint(TAny* aParams)

    {

    // That would lead in the destruction of the Qt's global statics in a different

    RLibrary libRef;

#ifdef _DEBUG

#endif

    libRef.Load(KSwtDllName);

    __ASSERT_DEBUG(addLibRef == KErrNone, User::Panic(KSwtDllName, 0));

    SwtTlsData* data = reinterpret_cast<SwtTlsData*>(aParams);

    JavaVM* vm = data->vm;

    // Try attach using the JavaVM pointer. At this point there's a Java thread

    // waiting ensuring that the VM has not closed down and the JavaVM pointer

    JNIEnv* env = NULL;

    void* args = NULL;

    jint attachStatus = vm->AttachCurrentThread((void**)&env, args);

    __ASSERT_DEBUG(attachStatus == 0, User::Panic(KSwtDllName, 0));

    // Notify the waiting Java thread that we have attached and it can continue

    notifyThreadInitStatus(attachStatus, data->initThreadId, &data->initStatus);

    RThread uiThread;

    TInt openStatus = uiThread.Open(uiThreadId);

    __ASSERT_DEBUG(openStatus == KErrNone, User::Panic(KSwtDllName, 0));

    TRequestStatus uiThreadRendezvous;

    if(openStatus == KErrNone)

        {

        uiThread.Rendezvous(uiThreadRendezvous);

        }

    // This is a workaround until QTBUG-5284 is resolved.

    while(ETrue)

        {

        User::WaitForAnyRequest();

        if(vm && openStatus == KErrNone) {

            if(uiThread.ExitType() != EExitPending)

                {

                vm->DetachCurrentThread();

                env = NULL;

                vm = NULL;

                }

            }

        }

    }

void SymbianUtils::startSupportThread(TAny* aParams)

    {