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

 //

 // Permission is hereby granted, free of charge, to any person obtaining a

 // copy of this software and/or associated documentation files (the

 // "Materials"), to deal in the Materials without restriction, including

 // without limitation the rights to use, copy, modify, merge, publish,

 // distribute, sublicense, and/or sell copies of the Materials, and to

 // permit persons to whom the Materials are furnished to do so, subject to

 // the following conditions:

 //

 // The above copyright notice and this permission notice shall be included

 // in all copies or substantial portions of the Materials.

 //

 // THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

 // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

 // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

 // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

 // MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.

 //

 // Description:

 // 

 //

 //

 #define KInitialIndexValue (-1)

 #include "owfmessagequeue.h"

 #include "owfdebug.h"

 #include <e32base.h>

 class CMessageQueue: public CBase

     {

     public:

         virtual ~CMessageQueue();

         static CMessageQueue* NewL();

         static CMessageQueue* NewLC();

         void Send(TInt msg, void* data);

         TInt Fetch(OWF_MESSAGE* msg, TInt timeout);

         TInt Fetch(OWF_MESSAGE* msg);

     private:

         CMessageQueue();

         void ConstructL();

     private:

         const static TInt iQueueSize = 16;

         OWF_MESSAGE iMessageArray[iQueueSize];

         RSemaphore iFetchSeamaphore;

         RSemaphore iSendSemaphore;

         RFastLock iProtectionMutex;

         TInt iSendIndex;

         TInt iFetchIndex;

     };

 CMessageQueue::CMessageQueue():

 iSendIndex(KInitialIndexValue),

 iFetchIndex(KInitialIndexValue)

     {

     }

 CMessageQueue::~CMessageQueue()

     {

     iFetchSeamaphore.Close();

     iSendSemaphore.Close();

     iProtectionMutex.Close();

     }

 void CMessageQueue::ConstructL()

     {

     User::LeaveIfError(iFetchSeamaphore.CreateLocal(0));

     User::LeaveIfError(iSendSemaphore.CreateLocal(iQueueSize));

     User::LeaveIfError(iProtectionMutex.CreateLocal());

     }

 CMessageQueue* CMessageQueue::NewLC()

     {

     CMessageQueue* self = new(ELeave) CMessageQueue();

     CleanupStack::PushL(self);

     self->ConstructL();

     return(self);

     }

 CMessageQueue* CMessageQueue::NewL()

     {

     CMessageQueue* self = CMessageQueue::NewLC();

     CleanupStack::Pop(self);

     return self;

     }

 void CMessageQueue::Send(TInt msg, void* data)

     {

     iSendSemaphore.Wait();

     iProtectionMutex.Wait();

     iSendIndex = (iSendIndex + 1) % iQueueSize;

     iMessageArray[iSendIndex].id = msg;

     iMessageArray[iSendIndex].data = data;

     iProtectionMutex.Signal();

     iFetchSeamaphore.Signal();

     }

 TInt CMessageQueue::Fetch(OWF_MESSAGE* msg, TInt timeout)

     {

     TInt ret = KErrNone;

     if (!msg)

         {

         return KErrArgument;

         }

     if ((ret = iFetchSeamaphore.Wait(timeout)) == KErrNone)

         {

         iProtectionMutex.Wait();

         if (iSendIndex == iFetchIndex)

             {

             iProtectionMutex.Signal();

             return KErrTimedOut;

             }

         else

             {

             iFetchIndex = (iFetchIndex + 1) % iQueueSize;

             *msg = iMessageArray[iFetchIndex];

             iProtectionMutex.Signal();

             iSendSemaphore.Signal();

             return KErrNone;

             }

         }

     return ret;

     }

 TInt CMessageQueue::Fetch(OWF_MESSAGE* msg)

     {

     if (!msg)

         {

         return KErrArgument;

         }

     iFetchSeamaphore.Wait();

     iProtectionMutex.Wait();

     iFetchIndex = (iFetchIndex + 1) % iQueueSize;

     *msg = iMessageArray[iFetchIndex];

     iProtectionMutex.Signal();

     iSendSemaphore.Signal();

     return KErrNone;

     }

 OWF_API_CALL void

 OWF_MessageQueue_Destroy(OWF_MESSAGE_QUEUE* queue)

 {

     if (!queue) 

         {

         return;

         }

     delete (CMessageQueue*)queue->queuePtr;

     queue->queuePtr = NULL;

 }

 OWF_API_CALL OWFint

 OWF_MessageQueue_Init(OWF_MESSAGE_QUEUE* queue)

 {

     if (!queue) 

         {

         return MSG_QUEUE_INIT_ERR;

         }

     TRAPD(err, queue->queuePtr = CMessageQueue::NewL());

     return (err || !queue->queuePtr) ? MSG_QUEUE_INIT_ERR : MSG_QUEUE_INIT_OK;

 }

 OWF_API_CALL void

 OWF_Message_Send(OWF_MESSAGE_QUEUE* queue,

                  OWFuint msg,

                  void* data)

 {

     OWF_ASSERT(queue);

     OWF_ASSERT(queue->queuePtr);

     ((CMessageQueue*)(queue->queuePtr))->Send(msg, data);

 }

 OWF_API_CALL OWFint

 OWF_Message_Wait(OWF_MESSAGE_QUEUE* queue,

                  OWF_MESSAGE* msg,

                  OWFint timeout)

 {

     OWF_ASSERT(queue);

     OWF_ASSERT(queue->queuePtr);

     OWF_ASSERT(msg);

     OWFint ret = 0;

     if (WAIT_FOREVER == timeout)

         {

         ret = ((CMessageQueue*)(queue->queuePtr))->Fetch(msg);

         }

     else

         {

         ret = ((CMessageQueue*)(queue->queuePtr))->Fetch(msg, timeout);

         }

     switch (ret)

         {

         case KErrNone:

             return MSG_QUEUE_WAIT_MSG_FETCHED;

         case KErrTimedOut:

             return MSG_QUEUE_WAIT_MSG_TIMEDOUT;

         default:

             return MSG_QUEUE_WAIT_MSG_ERR;

         }

 }