/*
* ============================================================================
*  Name        : btnotificationmanager.cpp
*  Part of     : bluetoothengine / btnotif
*  Description : Class for managing user notification and query objects, and for serializing access to the notification server.
*
*  Copyright © 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:
*  Nokia Corporation
* ============================================================================
* Template version: 4.1
*/

#include "btnotificationmanager.h"
#include "btnotifserver.h"

#include "bluetoothnotification.h"


// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------
// C++ default constructor
// ---------------------------------------------------------------------------
//
CBTNotificationManager::CBTNotificationManager( const CBTNotifServer* aServer )
:   iServer( aServer )
    {
    }


// ---------------------------------------------------------------------------
// Symbian 2nd-phase constructor
// ---------------------------------------------------------------------------
//
void CBTNotificationManager::ConstructL()
    {
    iAsyncCb = new( ELeave ) CAsyncCallBack( iServer->Priority() );
    TCallBack cb( AsyncCallback, this );
    iAsyncCb->Set( cb );
    }


// ---------------------------------------------------------------------------
// NewL.
// ---------------------------------------------------------------------------
//
CBTNotificationManager* CBTNotificationManager::NewL( const CBTNotifServer* aServer )
    {
    CBTNotificationManager* self = new( ELeave ) CBTNotificationManager( aServer );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }


// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CBTNotificationManager::~CBTNotificationManager()
    {
    iNotificationQ.ResetAndDestroy();
    iNotificationQ.Close();
    iUnusedQ.ResetAndDestroy();
    iUnusedQ.Close();
    delete iAsyncCb;
    }


// ---------------------------------------------------------------------------
// Get a new notification
// ---------------------------------------------------------------------------
//
CBluetoothNotification* CBTNotificationManager::GetNotification()
    {
    CBluetoothNotification* notification = NULL;
    if( iUnusedQ.Count() )
        {
        // Re-use the first idle notification.
        notification = iUnusedQ[0];
        iUnusedQ.Remove( 0 );
        }
    else
        {
        TRAP_IGNORE( notification = CBluetoothNotification::NewL( this ) );
        }
    if( notification )
        {
        if( iNotificationQ.Append( notification ) )
            {
            // In case the appending fails, we just delete the notification.
            // Otherwise we cannot keep track of it anymore.
            delete notification;
            notification = NULL;
            }
        }
    return notification;
    }


// ---------------------------------------------------------------------------
// Release the notification
// ---------------------------------------------------------------------------
//
void CBTNotificationManager::ReleaseNotification( CBluetoothNotification* aNotification )
    {
    __ASSERT_ALWAYS( aNotification, PanicServer( EBTNotifPanicBadArgument ) );
    TInt pos = iNotificationQ.Find( aNotification );
    __ASSERT_ALWAYS( pos > KErrNotFound, PanicServer( EBTNotifPanicMissing ) );
    // ToDo: Cancel outstanding notification!
    iNotificationQ.Remove( pos );
    TInt err = iUnusedQ.Append( aNotification );
    aNotification->Reset();  // Clean up notification's resources
    if( err )
        {
        // Just delete the notification.
        delete aNotification;
        }
    if( !iAsyncCb->IsActive() )
        {
        if( !iNotificationQ.Count() )
            {
            // Set the priority so that this is the last scheduled active object to execute.
            iAsyncCb->SetPriority( CActive::EPriorityIdle );
            }
        iAsyncCb->CallBack();
        }
    }


// ---------------------------------------------------------------------------
// Queue the notification with given priority
// ---------------------------------------------------------------------------
//
TInt CBTNotificationManager::QueueNotification( CBluetoothNotification* aNotification,
    TNotificationPriority aPriority )
    {
    TInt pos = iNotificationQ.Find( aNotification );
    __ASSERT_ALWAYS( pos > KErrNotFound, PanicServer( EBTNotifPanicMissing ) );
    if( aPriority == EPriorityHigh && pos != 0 )
        {
        // ToDo:  Move the note to the front of the queue
        }
    if( !iAsyncCb->IsActive() )
        {
		if( iAsyncCb->Priority() != iServer->Priority() )
			{
			// Reset priority back to original value
			// We first check the current priority, otherwise CActive will do an
			// unnecessary removal and adding of the callback from the active scheduler. 
			iAsyncCb->SetPriority( iServer->Priority() );
			}
        iAsyncCb->CallBack();
        }
    return KErrNone;
    }


// ---------------------------------------------------------------------------
// Process the notification queue and launch the next notification.
// ---------------------------------------------------------------------------
//
void CBTNotificationManager::ProcessNotificationQueueL()
    {
    if( iNotificationQ.Count() )
        {
        TInt err = iNotificationQ[0]->Show();
        // If the note is already showing, it will return KErrAlreadyExists
        (void) err; // ToDo: add error handling!!
        NOTIF_NOTHANDLED( !err || err == KErrAlreadyExists || err == KErrNotFound )
        }
    else
        {
        // No outstanding notifications, and unused notifications.
        // Clean up the unused notifications.
        iUnusedQ.ResetAndDestroy();
        iNotificationQ.Reset(); // the queue is empty, reset it.
        // Also clean up any resources.
        }
    }


// ---------------------------------------------------------------------------
// Callback for asynchronous processing of queued notification requests.
// ---------------------------------------------------------------------------
//
TInt CBTNotificationManager::AsyncCallback( TAny* aPtr )
    {
    TRAPD( err, ( (CBTNotificationManager*) aPtr )->ProcessNotificationQueueL() );
    return err;
    }