/*
* Copyright (c) 1999-2001 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 <eikenv.h>
#include <eikappui.h>
#include <eiksrvc.h>
#include <stdio.h>

#include "JesServer.h"
#include "CJavaEventServer.h"



const TInt KMaxUserName=64;
const TInt KMaxJesName=3+1+8+1+KMaxUserName+1+8;


class TJesName : public TBuf<KMaxJesName>
{
public:
    TJesName(const TDesC& aUserName);
    TJesName(const TDesC& aUserName,TInt aHandle);
private:
    void Build(const TDesC& aUserName);
};

class TJesParam : public MEventServer
{
public:
    virtual void Started(TInt aError, RServer2 aServer)
    {
        iServerHandle = aServer;
        iThread.RequestComplete(iStatus,aError);
    }
    virtual TAny* Arg() const
    {
        return iArg;
    }
public:
    RThread iThread;
    RServer2 iServerHandle;
    TRequestStatus* iStatus;
    TAny* iArg;
};

class CJesSession : public CSession2
{
    class TExecute
    {
    public:
        inline TInt operator()() const;
    private:
        TInt(*iFunc)(TAny*,TAny*,TAny*,TAny*,TAny*,TAny*,TAny*,TAny*,TAny*);
        TAny* iParam[9];
    };
private:
    void ServiceL(const RMessage2& aMessage);
    static TInt ExecuteTrap(const TExecute& aExecute);
};

class CJesScheduler : public CActiveScheduler, public MJesShutdown
{
public:
    static TInt Create(RServer2& serverHandle);
    virtual void Shutdown();
private:
    CJesScheduler();
    static void CreateL(RServer2& serverHandle);
private:
    CJesServer   iServer;
};

// Class TJesName

// The thread name is made up of the user name, the process Id and
// the address of this object.

_LIT(KName,"jes-");

TJesName::TJesName(const TDesC& aUserName)
//
// Construct the base Java Event Server name
//
{
    Build(aUserName);
}

TJesName::TJesName(const TDesC& aUserName,TInt aHandle)
//
// Construct the full Java Event Server name
//
{
    Build(aUserName);
    AppendNum(aHandle,EHex);
}

void TJesName::Build(const TDesC& aUserName)
//
// Create the base of the server name
//
{
    Copy(KName);
    TProcessId id(RProcess().Id());
    AppendNum(*reinterpret_cast<TInt*>(&id),EHex);
    Append('-');
    Append(aUserName);
    Append('@');
}


// class RJess

TInt RJess::Connect(RServer2& aServer)
//
// Establish an IPC session with the event server and share it
//
{
    TInt r=CreateSession(aServer, TVersion(), CJavaEventBase::ELastPriority + 1);
    if (r==KErrNone)
    {
        r=ShareAuto();
        if (r!=KErrNone)
            Close();
    }
    return r;
}

// class TJavaEventServer

inline TJavaEventServer::TJavaEventServer(CJavaEventServer* aServer)
        :iServer(aServer)
{}

EXPORT_C TJavaEventServer TJavaEventServer::NewL(const TDesC& aName, TThreadFunction aServerThread, TAny* aServerArg)
{
    return CJavaEventServer::NewL(aName, aServerThread, aServerArg, 0, 0);
}

EXPORT_C TJavaEventServer TJavaEventServer::NewL(const TDesC& aName, TThreadFunction aServerThread, TAny* aServerArg,
        TUint aStackSize, RAllocator* aHeap)
{
    return CJavaEventServer::NewL(aName, aServerThread, aServerArg, aStackSize, aHeap);
}

EXPORT_C void TJavaEventServer::Shutdown()
{
    iServer->Shutdown();
}

// class CJesServer

EXPORT_C CJesServer::CJesServer(MJesShutdown* aShutdown):
//
// The Java Event Server shares the session between all thread clients
//
        CServer2(0,ESharableSessions)
        , iShutdown(aShutdown)
{
}

CJesServer::~CJesServer()
{
}

CSession2* CJesServer::NewSessionL(const TVersion& /*version*/, const RMessage2& /*message*/) const
{
    return new(ELeave) CJesSession();
}

void CJesServer::Shutdown()
{
    iShutdown.Start();
}


// class CJesScheduler
CJesScheduler::CJesScheduler()
        : iServer(this)
{
}

void CJesScheduler::Shutdown()
{
    CActiveScheduler::Stop();
}

void CJesScheduler::CreateL(RServer2& serverHandle)
{
    CJesScheduler* s=new(ELeave) CJesScheduler;
    CActiveScheduler::Install(s);
    s->iServer.StartL(KNullDesC);
    serverHandle = s->iServer.Server();
}

TInt CJesScheduler::Create(RServer2& serverHandle)
//
// Create the Java Event thread scheduler and server
//
{
    TRAPD(r,CreateL(serverHandle));
    return r;
}

// java-side
void CJavaEventServer::AddRef()
{
    iMutex.Wait();
    ++iRef;
    iMutex.Signal();
}

// java-side
void CJavaEventServer::RemoveRef()
{
    iMutex.Wait();
    if ((--iRef == 0) && iShutdown)
    {
        iSession.Shutdown();
    }
    iMutex.Signal();
}

// java-side - consider purging event queue.
void CJavaEventServer::Shutdown()
{
    iMutex.Wait();
    iShutdown=ETrue;
    if (0 == iRef)
    {
        iSession.Shutdown();
    }
    iMutex.Signal();
}

TInt CJavaEventServer::ServerThread(TAny* aParam)
//
// The thread function for the Java event server thread
// This initialises the thread environment before reporting success
// and then starting its scheduler
//
{
    MEventServer* server  = static_cast<MEventServer*>(aParam);

    TInt err = KErrNoMemory;

    RServer2 serverHandle;

    CTrapCleanup* cleanup = CTrapCleanup::New();
    if (cleanup)
    {
        err = CJesScheduler::Create(serverHandle);
    }

    server->Started(err, serverHandle);   // don't touch server again - its gone.
    server = NULL;
    if (err==KErrNone)
    {
        CActiveScheduler::Start();
    }
    delete CActiveScheduler::Current();         // will delete all objects
    delete cleanup;
    return 0;
}

#ifndef JAVA_STACKSIZE
#define JAVA_STACKSIZE 0x2000
#endif

void CJavaEventServer::ConstructL(const TDesC& aUserName, TThreadFunction aServerThread, TAny* aServerArg,
                                  TUint aStackSize, RAllocator* aHeap)
//
// Main construction of the event server
//
{
    User::LeaveIfError(iMutex.CreateLocal());

    if (NULL == aServerThread)
    {
        // default thread function.
        aServerThread = &ServerThread;
    }

    TJesParam param;
    param.iArg = aServerArg;
    User::LeaveIfError(param.iThread.Duplicate(param.iThread,EOwnerProcess));   // make the thread handle process relative
    CleanupClosePushL(param.iThread);
    TRequestStatus s(KRequestPending);
    param.iStatus=&s;
    RThread js;
    if (aStackSize == 0)
    {
        aStackSize = JAVA_STACKSIZE;
    }

    TJesName name(aUserName,TJavaEventServer::Handle(this));
    User::LeaveIfError(js.Create(name,aServerThread,aStackSize,aHeap,&param,EOwnerProcess));
//    js.SetPriority(EPriorityMore);
    js.Resume();
    js.Close();
    User::WaitForRequest(s);            // wait for signal from server thread
    User::LeaveIfError(s.Int());
    CleanupStack::PopAndDestroy();      // param.iThread
    User::LeaveIfError(iSession.Connect(param.iServerHandle));
}

CJavaEventServer::CJavaEventServer()
{
}

CJavaEventServer::~CJavaEventServer()
{
    iSession.Close();
    iMutex.Close();
}

CJavaEventServer* CJavaEventServer::NewL(const TDesC& aUserName,TThreadFunction aServerThread, TAny* aServerArg,
        TUint aStackSize, RAllocator* aHeap)
{
    CJavaEventServer* self=new(ELeave) CJavaEventServer;
    CleanupStack::PushL(self);
    self->ConstructL(aUserName, aServerThread, aServerArg, aStackSize, aHeap);
    CleanupStack::Pop();
    return self;
}

// class CJavaEventBase

void CJavaEventBase::Run(JNIEnv& aJni)
//
// Dispatch this event and destroy the event object
//
{
    CJavaEventSourceBase& source = Object();

    // check if the event type is disposable before calling java callback
    // because if it's reusable it can be destroyed during servicing process
    TBool isDisposable = IsDisposable();

    if (!source.IsDisposed() && !aJni.IsSameObject(source.Peer(),0))
    {
        if (aJni.PushLocalFrame(16)==0)
        {
            Dispatch(aJni);
            if (aJni.ExceptionCheck())
            {   // Report any exceptions that were generated and clear them from the JNI environment
                aJni.ExceptionDescribe();
                aJni.ExceptionClear();
            }
            aJni.PopLocalFrame(0);
        }
    }
    if (isDisposable)
    {
        delete this;
    }
    // Close must be called last, because it may result in the destruction of this
    // event object if the event is a reusable event
    source.Close(aJni);
}

// class CJesSession

inline TInt CJesSession::TExecute::operator()() const
{
    return iFunc(iParam[0],iParam[1],iParam[2],iParam[3],iParam[4],iParam[5],iParam[6],iParam[7],iParam[8]);
}

TInt CJesSession::ExecuteTrap(const TExecute& aExecute)
//
// Execute the client function inside a trap harness
//
{
    TRAPD(r,aExecute());
    return r;
}


void CJesSession::ServiceL(const RMessage2& m)
//
// Invoke the requested client function
//
{
    switch (m.Function())
    {
    case EJessExecute:
    {
        const TExecute& e = *static_cast<const TExecute*>(m.Ptr0());
        TInt result = e();
        m.Complete(result != KRequestPending ? result : KErrNotSupported);
    }
    break;

    case EJessExecuteTrap:
        m.Complete(ExecuteTrap(*static_cast<const TExecute*>(m.Ptr0())));
        break;

    case EJessShutdown:
        ((CJesServer*)Server())->Shutdown();
        m.Complete(KErrNone);
        break;
    }
}

CJesShutdown::CJesShutdown(MJesShutdown* aShutdown)
        : CActive(CActive::EPriorityStandard)
        , iShutdown(aShutdown)
{
}

void CJesShutdown::Start()
{
    CActiveScheduler::Add(this);
    iStatus=KRequestPending;
    TRequestStatus* status = &iStatus;
    User::RequestComplete(status, KErrNone);
    SetActive();
}

void CJesShutdown::RunL()
{
    ASSERT(iShutdown);
    iShutdown->Shutdown();
    iShutdown = NULL;
}

TInt CJesShutdown::RunError(TInt aError)
{
    if (aError == KLeaveExit)
    {
        return aError;
    }
    return KErrNone;
}

void CJesShutdown::DoCancel()
{
    // nop
}

// Helper method to trace output (int) to Java side, eg. System.out
void CJavaEventServer::Trace(JNIEnv& aJni, TInt value)
{
    jclass clazz = aJni.FindClass("com/symbian/lcdjava/lang/SystemExtensions");
    jmethodID method = aJni.GetStaticMethodID(clazz, "trace" , "(I)V");
    aJni.CallStaticVoidMethod(clazz, method, value);
}

// Notify Java thread of a new event
void CJavaEventServer::NotifyJavaCall(TInt aEvent, TInt aPriority)
{
    CEventQueue::NotifyServer(aEvent, aPriority);
}


void CJavaEventServer::Cleanup(RArray<TInt>& aServerHandles)
{
    CEventQueue::Cleanup();

    // Loop through event server instances and remove each
    for (TInt i = aServerHandles.Count() - 1; i >= 0; --i)
    {
        TInt handle = aServerHandles[i];
        aServerHandles.Remove(i);
        delete JavaUnhand<CJavaEventServer>(handle);
    }
}