// Copyright (c) 2009 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 "systemsharedbufs.h"
#include "systemsharedasyncalloc.h"
#include "commsbufasyncreqinternal.h"


CSystemSharedPoolAsyncAlloc::CSystemSharedPoolAsyncAlloc(CSystemSharedBufPool& aPool, MAsyncAllocNotifier& aNotifier)
: CActive(EPriorityStandard),
iPool(aPool),
iNotifier(aNotifier)
	{
	CActiveScheduler::Add(this);
	}

CSystemSharedPoolAsyncAlloc::~CSystemSharedPoolAsyncAlloc()
	{
	Deactivate();	
	}
	
void CSystemSharedPoolAsyncAlloc::Activate(TInt aFreeBufs)
	{
	if(!IsActive())
		{
		iStatus = KRequestPending;
		iPool.Pool().RequestFreeSpaceNotification(aFreeBufs, iStatus);
		SetActive();			
		}
	}

void CSystemSharedPoolAsyncAlloc::Deactivate()
	{		
	Cancel();
	}

void CSystemSharedPoolAsyncAlloc::RunL()
	{
	User::LeaveIfError(iStatus.Int());
	iNotifier.OnCompletion();
	}

TInt CSystemSharedPoolAsyncAlloc::RunError(TInt aError)
	{
	iNotifier.OnError(aError);
	return KErrNone;
	}

void CSystemSharedPoolAsyncAlloc::DoCancel()
	{
	iPool.Pool().CancelFreeSpaceNotification(iStatus);
	}

// -------------------------------------------------------------------------

CSystemSharedAsyncAlloc* CSystemSharedAsyncAlloc::New(const RPointerArray<CSystemSharedBufPool>& aPools)
	{
	CSystemSharedAsyncAlloc* self = new CSystemSharedAsyncAlloc();
	if(self)
		{
		if (self->Construct(aPools) == KErrNone)
			{
			return self;
			}
		else
			{
			delete self;	
			}
		}
	return NULL;	
	}

CSystemSharedAsyncAlloc::CSystemSharedAsyncAlloc()
: CActive(EPriorityStandard),
iRequestState(EMakeRequest),
iSignalled(ETrue)
    {
    CActiveScheduler::Add(this);
    }

CSystemSharedAsyncAlloc::~CSystemSharedAsyncAlloc()
	{
	__ASSERT_DEBUG(iAllocsPending.IsEmpty(), User::Invariant());
	Cancel();
	iAsyncAllocPools.ResetAndDestroy();	
	iAsyncAllocPools.Close();
	iAsynAllocLock.Close();
	iOwnerThread.Close();
	}

TInt CSystemSharedAsyncAlloc::Construct(const RPointerArray<CSystemSharedBufPool>& aPools)
	{
    TInt err = KErrNone;
	for(TInt i = 0; i < aPools.Count(); ++i)
		{
		CSystemSharedPoolAsyncAlloc* asyncPool = new CSystemSharedPoolAsyncAlloc(*(aPools[i]), *this);
		if(asyncPool)
		    {
		    if(iAsyncAllocPools.Append(asyncPool) != KErrNone)
		        {
		        delete asyncPool;
		        err = KErrNoMemory;
		        break;
		        }
		    }
		else
		    {
		    err = KErrNoMemory;
		    break;
		    }		
		}
	if(err == KErrNone)
	    {
	    iAllocsPending.SetOffset(_FOFF(CCommsBufAsyncRequest, iLink));      
	    err = iAsynAllocLock.CreateLocal();
	    if(err == KErrNone)
	        {
	        TThreadId id = RThread().Id();
	        err = iOwnerThread.Open(id);
	        if(err == KErrNone)
	            {
	            // Activate the AO. 
                ActivateSelf();
	            }
	        }
	    }
	return err;
	}

void CSystemSharedAsyncAlloc::StartRequest(CCommsBufAsyncRequest& aRequest)
	{
	iAsynAllocLock.Wait();
	if(iAllocsPending.IsEmpty())
	    {
	    // We do not have anything in the pending alloc queue. 
	    // Kick off the AO.
	    CompleteSelf();
	    }
	iAllocsPending.AddLast(aRequest);
	iAsynAllocLock.Signal();        
	}

void CSystemSharedAsyncAlloc::CancelRequest(CCommsBufAsyncRequest& aRequest)
	{
	iAsynAllocLock.Wait();
    aRequest.iLink.Deque();
    aRequest.Complete(KErrCancel); 
    CompleteSelf();
    iAsynAllocLock.Signal();
	}

void CSystemSharedAsyncAlloc::MakePoolAsyncRequest()
    {
    iAsynAllocLock.Wait();
    MakePoolRequest();
    ActivateSelf();
    iAsynAllocLock.Signal();
    }

void CSystemSharedAsyncAlloc::MakePoolRequest()
    {
    if(!iAllocsPending.IsEmpty())
        {
        CCommsBufAsyncRequest* req = iAllocsPending.First();
        for(TInt i = 0; i < iAsyncAllocPools.Count(); ++i)
            {            
            CSystemSharedPoolAsyncAlloc* asyncPool = iAsyncAllocPools[i];
            TInt poolBufSize = asyncPool->iPool.BufSize();
            if(poolBufSize >= req->iMinSize && poolBufSize <= req->iMaxSize)
                {
                TInt freeBufs = req->iSize / poolBufSize;
                freeBufs = ((req->iSize % asyncPool->iPool.BufSize()) == 0) ? freeBufs : (freeBufs + 1);
                asyncPool->Activate(freeBufs);              
                }
            }
        }    
    }

void CSystemSharedAsyncAlloc::CancelAllPoolRequest()
    {
    for(TInt i = 0; i < iAsyncAllocPools.Count(); ++i)
        {
        iAsyncAllocPools[i]->Deactivate();  
        }
    }

void CSystemSharedAsyncAlloc::CancelPoolAsyncRequest()
    {
    iAsynAllocLock.Wait();
    CancelAllPoolRequest();
    ActivateSelf();
    if(!iAllocsPending.IsEmpty())
        {
        CompleteSelf();
        }
    iAsynAllocLock.Signal();
    }

 void CSystemSharedAsyncAlloc::RunL()
     {
     // 
     switch(iRequestState)
         {
         case EMakeRequest:
         MakePoolAsyncRequest();         
         break;
         
         case ECancelRequest:
         CancelPoolAsyncRequest();
         iRequestState = EMakeRequest;
         break;
         
         default:
         // We should never reach here
         CommsBuf::Panic(EMBuf_AsyncAllocInvalidState);
         break;
         }
     
    }
 
 void CSystemSharedAsyncAlloc::DoCancel()
     {
     TRequestStatus* requestStatusPtr = &iStatus;
     iOwnerThread.RequestComplete(requestStatusPtr, KErrCancel);    
     }

void CSystemSharedAsyncAlloc::ActivateSelf()
    {
    if(iSignalled)
        {
        iStatus = KRequestPending;
        SetActive();
        iSignalled = EFalse;
        }
    }
 
void CSystemSharedAsyncAlloc::CompleteSelf()
    {
    if(!iSignalled)
        {
        TRequestStatus* requestStatusPtr = &iStatus;
        iOwnerThread.RequestComplete(requestStatusPtr, KErrNone);
        iSignalled = ETrue;
        }
    }

void CSystemSharedAsyncAlloc::OnCompletion()
    {
    CompleteAsyncAllocs();
    }

void CSystemSharedAsyncAlloc::OnError(TInt aError)
    {
    // We hit with an error from the system pool.
      // complete all alloc request with that error.
      CCommsBufAsyncRequest* req;
      iAsynAllocLock.Wait();
      if(!iAllocsPending.IsEmpty())
          {
          TDblQueIter<CCommsBufAsyncRequest> iter(iAllocsPending);
          while (req = iter++, req != NULL)
              {
              req->Complete(aError);                     
              }          
          }
       iAsynAllocLock.Signal();                  
    }

void CSystemSharedAsyncAlloc::CompleteAsyncAllocs()
    {
    CCommsBufAsyncRequest *req;

    iAsynAllocLock.Wait();
    TDblQueIter<CCommsBufAsyncRequest> iter(iAllocsPending);
    while (req = iter++, req != NULL)
        {
        RCommsBufChain chain;
        chain.Alloc(req->iSize, req->iMinSize, req->iMaxSize, req->iAllocator);
        if(!chain.IsEmpty())
            {
            req->iBufQ.Assign(chain);
            req->Complete(KErrNone);                    
            }
        }
    // We are in the same thread. Cancel the current pool requests.
    CancelAllPoolRequest();
    // Make the pool request if needed.
    MakePoolRequest();
    iAsynAllocLock.Signal();
    }