// 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:
// Reference EGL implementation to support EGL sync objects and OpenWF extensions

#include "eglprivate.h"

CEglDisplay::CEglDisplay(RHeap& aHeap):
    iHandle(KEglDefaultDisplayHandle),
	iHeap(aHeap)
	{
	}

CEglDisplay::~CEglDisplay()
	{
	Terminate();
	
	if (iSyncObjList)
	    {
        __ASSERT_DEBUG(iSyncObjList->Count() == 0, User::Panic(KEglPanicCategory, EEglPanicOutstandingSyncObj));

        // we're about to free hash map and its underlying memory, make sure EGL shared heap is used
        RHeap* callerHeap = User::SwitchHeap(&iHeap);
        iSyncObjList->Close();
        delete iSyncObjList;
        User::SwitchHeap(callerHeap);
	    }
	}

TInt CEglDisplay::Initialize()
	{
	TInt err = KErrNone;
	if (iIsInitialized)
		{
		return err;
		}

	// hash map is only created once, check that when re-initialising display
	if (iSyncObjList)
	    {
	    iIsInitialized = ETrue;
	    }
	else
	    {
	    // make sure underlying hash implementation memory is allocated in share heap
	    //
        RHeap* callerHeap = User::SwitchHeap(&iHeap);
        iSyncObjList = new REglSyncHashMap;
        if (iSyncObjList)
            {
            iIsInitialized = ETrue;
            }
        else
            {
            err = KErrNoMemory;
            }
        User::SwitchHeap(callerHeap);        
	    }
	
	return err;
	}

void CEglDisplay::Terminate()
	{
	if (!iIsInitialized)
		{
		return;
		}

    REglSyncHashMap::TIter iter(*iSyncObjList);
    // iter begin at index -1, must move it once to get to first item
    while (iter.NextKey())
        {
        CEglSync** ppSyncObj = iter.CurrentValue();
        __ASSERT_DEBUG(ppSyncObj, User::Panic(KEglPanicCategory, EEglPanicInvalidSyncObj));
        
        // In a regular iteration, we should not modify the hash map itself while it is being iterated.
        // However, this is not a regular iteration, we need to remove destroyed object from
        // this hash map without using additional memory e.g. copying destroyed object key temporarily.
        // The reason we do not want to do that is because allocating memory can fail and Terminate
        // must not fail.
        CEglSync* syncObj = *ppSyncObj;
        
        // Destroy() will switch current heap to the EGL shared heap and restore it back.
        // It will also remove the sync object from hash map, but not necessarily delete it (because
        // some other threads may still use it)
        syncObj->Destroy();
        iter.Reset();
        }
    
	iIsInitialized = EFalse;
	}

CEglSync* CEglDisplay::FindSyncObj(EGLSyncKHR aObj) const
	{
	__ASSERT_DEBUG(iSyncObjList, User::Panic(KEglPanicCategory, EEglPanicDisplayStateInvalid));

	const TInt key = reinterpret_cast<TInt>(aObj);
	CEglSync** ppso = iSyncObjList->Find(key);
	CEglSync* syncObj = ppso ? *ppso : NULL;
	
	return syncObj;
	}

CEglSync* CEglDisplay::CreateSyncObj()
	{
    __ASSERT_DEBUG(iSyncObjList, User::Panic(KEglPanicCategory, EEglPanicDisplayStateInvalid));
    
    CEglSync* syncObj = CEglSync::Create(*this);

    return syncObj;
	}

TInt CEglDisplay::DestroySyncObj(EGLSyncKHR aSyncObj)
	{
    __ASSERT_DEBUG(iSyncObjList, User::Panic(KEglPanicCategory, EEglPanicDisplayStateInvalid));

    CEglSync* syncObj = reinterpret_cast<CEglSync*>(aSyncObj);
    const TInt key = reinterpret_cast<TInt>(syncObj);
    CEglSync** ppso = iSyncObjList->Find(key);
    if (!ppso)
        {
        return KErrNotFound;
        }

    // Destroy() will not delete sync obj or remove it from the list if it is still being used in other threads
    // if there is no more reference to this sync obj when Destroy() is called, it will delete the object and remove it from the list
    __ASSERT_DEBUG(syncObj == *ppso, User::Panic(KEglPanicCategory, EEglPanicInvalidSyncObj));
    syncObj->Destroy();

    return KErrNone;
	}

TInt CEglDisplay::RegisterSyncObj(CEglSync& aSyncObj)
    {
    __ASSERT_DEBUG(&iHeap == &User::Heap(), User::Panic(KEglPanicCategory, EEglPanicInvalidHeap));
    __ASSERT_DEBUG(iSyncObjList, User::Panic(KEglPanicCategory, EEglPanicDisplayStateInvalid));
    
    const TInt key = reinterpret_cast<TInt>(&aSyncObj);
    const TInt err = iSyncObjList->Insert(key, &aSyncObj);

    return err;
    }

void CEglDisplay::UnregisterSyncObj(CEglSync& aSyncObj)
    {
    __ASSERT_DEBUG(&iHeap == &User::Heap(), User::Panic(KEglPanicCategory, EEglPanicInvalidHeap));
    __ASSERT_DEBUG(iSyncObjList, User::Panic(KEglPanicCategory, EEglPanicDisplayStateInvalid));
    
    const TInt key = reinterpret_cast<TInt>(&aSyncObj);
    const TInt err = iSyncObjList->Remove(key);
    // the only possible error is KErrNotFound which should never happen in our case
    __ASSERT_DEBUG(err == KErrNone, User::Panic(KEglPanicCategory, EEglPanicInvalidSyncObj));
    }