/*
* Copyright (c) 2006 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 "mcetimermanager.h"
#include "mcesrvlogs.h"
#include "mcesip.h"

// Granularity for timer entry array iEntries
const TInt KArrayGranularity( 8);

// One millisecond as microseconds
const TInt KOneMillisAsMicros( 1000);

// -----------------------------------------------------------------------------
// CMceTimerManager::NewL
// -----------------------------------------------------------------------------
//

CMceTimerManager* CMceTimerManager::NewL()
    {
    CMceTimerManager* self = CMceTimerManager::NewLC();
    CleanupStack::Pop(self);
    return self;
    }

// -----------------------------------------------------------------------------
// CMceTimerManager::NewLC
// -----------------------------------------------------------------------------
//
CMceTimerManager* CMceTimerManager::NewLC()
    {
    CMceTimerManager* self = new( ELeave ) CMceTimerManager;
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
    }

// -----------------------------------------------------------------------------
// CMceTimerManager::~CMceTimerManager
// -----------------------------------------------------------------------------
//
CMceTimerManager::~CMceTimerManager()
    {
    if(iTimerContainer)
    	{
    	iTimerContainer->Cancel();
    	delete iTimerContainer;
    	}
	iEntries.ResetAndDestroy();
    }

// -----------------------------------------------------------------------------
// CMceTimerManager::StartL
// -----------------------------------------------------------------------------
//
TMceTimerId CMceTimerManager::StartL(MMCEExpirationHandler* aObserver,
        TUint aMilliseconds)
    {
    MCESRV_DEBUG("2 CMceTimerManager::StartL, Entry");
    return StartL(aObserver, aMilliseconds, NULL);
    }

// -----------------------------------------------------------------------------
// CMceTimerManager::StartL
// -----------------------------------------------------------------------------
//
TMceTimerId CMceTimerManager::StartL(MMCEExpirationHandler* aObserver,
        TUint aMilliseconds, TAny* aTimerParam)
    {
    MCESRV_DEBUG("CMceTimerManager::StartL, Entry");
    // Do not accept a NULL observer
    if ( !aObserver)
        {
        User::Leave(KErrArgument);
        }

    // Get new unique timer id

    TMceTimerId newTimerId = NewTimerId();
    MCESRV_DEBUG_DVALUES( "timer", newTimerId, "timeout", aMilliseconds );

    // Define a new entry with the new id
    TEntry *newEntry = new ( ELeave ) TEntry();
    CleanupStack::PushL( newEntry );
    
    newEntry->iId = newTimerId;
    newEntry->iObserver = aObserver;
    newEntry->iObserverParam = aTimerParam;
    newEntry->iCallBack = TCallBack( TimerExpiredCallBack, newEntry );
    newEntry->iEntry = TDeltaTimerEntry( newEntry->iCallBack );
    newEntry->iTimerManager = this;

    iEntries.InsertL(newEntry, 0);
    CleanupStack::Pop( newEntry );
    
    TTimeIntervalMicroSeconds interval( TInt64( aMilliseconds ) * KOneMillisAsMicros );

    if (KErrNone != iTimerContainer->QueueLong( interval, newEntry->iEntry ) )
        {
        MCESRV_DEBUG("CMceTimerManager:: CDeltaTimer::QueueLong Error!!!");
        return CMceTimerManager::KNoSuchTimer;
        }

    MCESRV_DEBUG("CMceTimerManager::StartL, Exit");
    return newEntry->iId;

    }

// -----------------------------------------------------------------------------
// CMceTimerManager::Stop
// -----------------------------------------------------------------------------
//
TInt CMceTimerManager::Stop(TMceTimerId aTimerId)
    {
    MCESRV_DEBUG("CMceTimerManager::Stop, Entry");
    MCESRV_DEBUG_DVALUE("timer", aTimerId );

    // Find the timer entry to be stopped
    TInt entryIndex = FindEntry(aTimerId);
    if (entryIndex == KErrNotFound)
        {
        MCESRV_DEBUG("CMceTimerManager::Stop - Invalid TimerId, timer not found");
        return KErrNotFound;
        }

    // Remove timer information from container and delete entry
    TEntry* entry = iEntries[entryIndex];
    iTimerContainer->Remove(entry->iEntry);
    iEntries.Remove(entryIndex);
    delete entry;
    entry = NULL;

    MCESRV_DEBUG("CMceTimerManager::Stop, Exit");
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CMceTimerManager::IsRunning
// -----------------------------------------------------------------------------
//
TBool CMceTimerManager::IsRunning(TMceTimerId aTimerId) const
    {

    TInt entryIndex = FindEntry(aTimerId);
    if (entryIndex != KErrNotFound)
        {
        return ETrue;
        }
    return EFalse;
    }

// -----------------------------------------------------------------------------
// CMceTimerManager::NewTimerId
// -----------------------------------------------------------------------------
//
TMceTimerId CMceTimerManager::NewTimerId()
    {
    // Note that a rolling unsigned 32bit integer id counter
    // is not strictly unique - however, it is not possible
    // to have a timer with id 1 and id 2^32-1 at the same time
    // due to time and memory constraints.
    iTimerIdCounter++;
    if (iTimerIdCounter == KNoSuchTimer)
        {
        iTimerIdCounter++;
        }
    return iTimerIdCounter;
    }

// -----------------------------------------------------------------------------
// CMceTimerManager::FindEntry
// -----------------------------------------------------------------------------
//
TInt CMceTimerManager::FindEntry(TMceTimerId aTimerId) const
    {
    // Search for an entry with a matching id
    TInt count = iEntries.Count();
    for (TInt i = 0; i < count; i++)
        {

        if (iEntries[ i ]->iId == aTimerId)
            {

            return i;

            }
        }

    return KErrNotFound;
    }

// -----------------------------------------------------------------------------
// CMceTimerManager::CMceTimerManager
// -----------------------------------------------------------------------------
//
CMceTimerManager::CMceTimerManager() :
    iEntries(KArrayGranularity), iTimerIdCounter(KNoSuchTimer),
            iTimerContainer(NULL)

    {
    }

// -----------------------------------------------------------------------------
// CMceTimerManager::ConstructL
// -----------------------------------------------------------------------------
//
void CMceTimerManager::ConstructL()
    {

    iTimerContainer = CDeltaTimer::NewL(CActive::EPriorityStandard);

    }

// -----------------------------------------------------------------------------
// CMceTimerManager::TimerExpiredCallBack
// -----------------------------------------------------------------------------
//
TInt CMceTimerManager::TimerExpiredCallBack(TAny *aPtr)
    {

    MCESRV_DEBUG("TimerExpiredCallBack, Entry");
    if (aPtr != NULL)
        {

        TEntry* entry = static_cast<TEntry*> (aPtr );
        MCESRV_DEBUG_DVALUE(
                "CMceTimerManager:timer expired - calling observer.timer", entry->iId );

        // Call timer expired function
        TRAP_IGNORE( entry->iObserver->TimerExpiredL( entry->iId,
                        entry->iObserverParam ) );

        // Remove the TEntry pointer from iEntries
        TInt index = entry->iTimerManager->iEntries.Find(entry);
        if (index != KErrNotFound)
            {
            entry->iTimerManager->iEntries.Remove(index);
            }

        // Delete entry
        delete entry;
        return KErrNone;

        }

    MCESRV_DEBUG("TimerExpiredCallBack, Exit");
    return KErrArgument;

    }

// -----------------------------------------------------------------------------
// CMceTimerManager::TEntry::TEntry
// -----------------------------------------------------------------------------
//
CMceTimerManager::TEntry::TEntry() :
    iId(KNoSuchTimer), iObserver( NULL), iObserverParam( NULL), iTimerManager( NULL )
    {
    }