/*
* 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:
*
*/


#ifndef CJAVAEVENTSERVER_H
#define CJAVAEVENTSERVER_H

#include <e32std.h>
#include <e32cmn.h>

#include "mevents.h"

enum {EJessExecute,EJessExecuteTrap, EJessShutdown};

class RJess : public RSessionBase
{
public:
    TInt Connect(RServer2& aServer);
    inline TInt Execute(TAny* aParam)
    {
        return SendReceive(EJessExecute,TIpcArgs(aParam));
    }
    inline TInt ExecuteTrap(TAny* aParam)
    {
        return SendReceive(EJessExecuteTrap,TIpcArgs(aParam));
    }
    inline TInt Shutdown()
    {
        return SendReceive(EJessShutdown, TIpcArgs());
    }
};

class CJavaEventServer : public CBase
{
public:
    ~CJavaEventServer();
    static CJavaEventServer* NewL(const TDesC& aName,TThreadFunction aServerThread, TAny* aServerArg,
                                  TUint aStackSize = 0, RAllocator* aHeap = 0);

    // Notify Java dispatcher thread about new event, called from C++ thread
    static void NotifyJavaCall(TInt aEvent, TInt aPriority);

    // Cleanup the event server stuff, called from Java thread through JNI
    static void Cleanup(RArray<TInt>& aServerHandles);

    // Helper method to do tracing from the native to the Java side
    static void Trace(JNIEnv& aJni, TInt aValue);

    inline RJess& Session()
    {
        return iSession;
    }
    void PostEvent(CJavaEventBase* aEvent, TInt aPriority);
    static TInt ServerThread(TAny* aParam);

    void AddRef();
    void RemoveRef();
    void Shutdown();

private:
    CJavaEventServer();
    void ConstructL(const TDesC& aUserName,TThreadFunction aServerThread, TAny* aServerArg,
                    TUint aStackSize, RAllocator* aHeap);

private:
    TInt  iRef;
    RJess iSession;
    TBool iShutdown;
    RCriticalSection iMutex;

};

// CIntQueue helper class implements an integer FIFO queue The implementation is based on
// fixed-sized array, because we don't want any garbage to be collected here and we don't
// want to grab all the memory due to some misbehaving midlet. Synchronization is provided
// in putItem() and removeItem() functions so it's safe to call them from different threads

class CIntQueue : public CBase
{

public:
    virtual ~CIntQueue();

    static CIntQueue* NewL();        // two-phased constructor
    static CIntQueue* NewLC();       // two-phased constructor

    void  Enqueue(TInt aValue);      // add integer to the end of the queue
    TInt  Dequeue();                 // return integer from the beginning of the queue
    TBool IsEmpty();                 // checks if there are any items in queue

private:
    void PutItem(TInt aItem);        // put new item to the buffer
    TInt RemoveItem();               // take item from the buffer

    CIntQueue();                     // default C++ constructor
    void ConstructL();               // by default Symbian 2nd phase constructor is private

private:
    RArray<TInt>      iQueue;
    RMutex            iMutex;        // protect a critical regions of code
    RSemaphore        iFull;         // counts full buffer slots
    TInt              iCompressCounter; // counts event dequeuing
};

// CEventLock implements queues for manipulating of event and notification handlers.

class CEventQueue : public CBase
{

public:
    virtual ~CEventQueue();

    void NewEvent(TInt aEvent);
    TInt GetNext();

    static void NotifyServer(TInt aEvent, TInt aThreadNumber);
    static void OnCloseThreads();

    static void InitL();
    static void Cleanup();

    static CEventQueue* GetQueue(TInt aThread);
    static const TInt KDispatchThreads = 2;      // two dispatching threads: events and notifications

private:
    CEventQueue();
    void ConstructL();

private:
    CIntQueue* iEventQueue;                      // queue for storing event handles
};

// clean-up event server objects on vm exit
void CleanupEventServer();
// init event server objects on vm start
void InitEventServer();

#endif // CJAVAEVENTSERVER_H