/*
* Copyright (c) 2002-2004 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:  Implementation of CProEngNotifyHandlerImpl.
*
*/



// INCLUDE FILES
#include    "CProEngNotifyHandlerImpl.h"
#include    <MProEngProfileActivationObserver.h>
#include    <MProEngActiveProfileObserver.h>
#include    <MProEngProfileObserver.h>
#include    <MProEngProfileNameArrayObserver.h>
#include    <ProfileEngineConstants.h>
#include    "ProfileEnginePrivateCRKeys.h"
#include    <ProfileEnginePrivatePSKeys.h>
#include    "CProEngProfileActivationDelegate.h"
#include    "CProEngActiveProfileDelegate.h"
#include    "CProEngProfileNameArrayEventDelegate.h"
#include    "CProEngProfileEventDelegate.h"


// ============================= LOCAL FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// CompareDelegates
//
// Comparison function to check that RPointerArray does not already
// contain the given delegate for profile events
// -----------------------------------------------------------------------------

TBool CompareDelegates( const CProEngProfileEventDelegate& aDelegate1,
                        const CProEngProfileEventDelegate& aDelegate2 )
    {
    return ( aDelegate1.ProfileId() == aDelegate2.ProfileId() );
    }
 
// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// CProEngNotifyHandlerImpl::CProEngNotifyHandlerImpl
// -----------------------------------------------------------------------------
//
CProEngNotifyHandlerImpl::CProEngNotifyHandlerImpl()
    {
    }

// -----------------------------------------------------------------------------
// CProEngNotifyHandlerImpl::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CProEngNotifyHandlerImpl* CProEngNotifyHandlerImpl::NewL()
    {
    return new ( ELeave ) CProEngNotifyHandlerImpl();
    }

// Destructor
CProEngNotifyHandlerImpl::~CProEngNotifyHandlerImpl()
    {
    CancelAll();
    //iProfileEventDelegates.ResetAndDestroy();
    }

// -----------------------------------------------------------------------------
// CProEngNotifyHandlerImpl::RequestProfileActivationNotifications
// -----------------------------------------------------------------------------
//
TInt CProEngNotifyHandlerImpl::RequestProfileActivationNotificationsL(
        MProEngProfileActivationObserver& aObserver )
    {
    if( iActiveIdEventDelegate )
        {
        return KErrAlreadyExists;
        }

    iActiveIdEventDelegate =
            CProEngProfileActivationDelegate::NewL( aObserver );

    // make the actual request to the Publish & Subscribe:
    TInt result( iActiveIdEventDelegate->RequestNotification() );
    if( result != KErrNone )
        {
        delete iActiveIdEventDelegate;
        iActiveIdEventDelegate = NULL;
        }

    return result;
    }

// -----------------------------------------------------------------------------
// CProEngNotifyHandlerImpl::RequestActiveProfileNotificationsL
// -----------------------------------------------------------------------------
//
TInt CProEngNotifyHandlerImpl::RequestActiveProfileNotificationsL(
        MProEngActiveProfileObserver& aObserver )
    {
    if( iActiveProfileEventDelegate )
        {
        return KErrAlreadyExists;
        }

    iActiveProfileEventDelegate = new ( ELeave ) CProEngActiveProfileDelegate(
            aObserver );

    // make the actual request to the Publish & Subscribe:
    TInt result( iActiveProfileEventDelegate->RequestNotification() );
    if( result != KErrNone )
        {
        delete iActiveProfileEventDelegate;
        iActiveProfileEventDelegate = NULL;
        }

    return result;
    }

// -----------------------------------------------------------------------------
// CProEngNotifyHandlerImpl::RequestProfileNotificationsL
// -----------------------------------------------------------------------------
//
TInt CProEngNotifyHandlerImpl::RequestProfileNotificationsL(
        MProEngProfileObserver& aObserver,
        TInt aProfileId )
    {
    if( ( aProfileId < 0 ) || // profile id cannot be negative
        // or greater than the last dynamic profile id
        ( aProfileId > KProfileBaseDynamicProfileId +
                       KProfilesMaxNumberOfDynamicProfiles ) )
        {
        return KErrNotFound;
        }

    CProEngProfileEventDelegate* delegate = CProEngProfileEventDelegate::NewL(
            aProfileId, aObserver );
            
    TIdentityRelation<CProEngProfileEventDelegate> relation( CompareDelegates );
    if( iProfileEventDelegates.Find( delegate, relation ) != KErrNotFound )
        { // an observer has already been registered for the given profile id
        delete delegate;
        return KErrAlreadyExists;
        }

    TInt result( iProfileEventDelegates.Append( delegate ) );
    if( result == KErrNone )
        {
        // make the actual request to the Central Repository:
        result = delegate->RequestNotification();
        }

    if( result != KErrNone )
        {
        iProfileEventDelegates.Remove( iProfileEventDelegates.Count() - 1 );
        delete delegate;
        }

    return result;
    }

// -----------------------------------------------------------------------------
// CProEngNotifyHandlerImpl::RequestProfileNameArrayNotificationsL
// -----------------------------------------------------------------------------
//
TInt CProEngNotifyHandlerImpl::RequestProfileNameArrayNotificationsL(
        MProEngProfileNameArrayObserver& aObserver )
    {
    if( iNameArrayEventDelegate )
        {
        return KErrAlreadyExists;
        }

    iNameArrayEventDelegate = CProEngProfileNameArrayEventDelegate::NewL(
            aObserver );
            
    // make the actual request to the Central Repository:
    TInt result( iNameArrayEventDelegate->RequestNotification() );
    if( result != KErrNone )
        {
        delete iNameArrayEventDelegate;
        iNameArrayEventDelegate = NULL;
        }

    return result;
    }

// -----------------------------------------------------------------------------
// CProEngNotifyHandlerImpl::CancelProfileActivationNotifications
// -----------------------------------------------------------------------------
//
void CProEngNotifyHandlerImpl::CancelProfileActivationNotifications()
    {
    if( iActiveIdEventDelegate )
        {
        iActiveIdEventDelegate->Cancel();
        delete iActiveIdEventDelegate;
        iActiveIdEventDelegate = NULL;
        }
    }

// -----------------------------------------------------------------------------
// CProEngNotifyHandlerImpl::CancelActiveProfileNotifications
// -----------------------------------------------------------------------------
//
void CProEngNotifyHandlerImpl::CancelActiveProfileNotifications()
    {
    if( iActiveProfileEventDelegate )
        {
        iActiveProfileEventDelegate->Cancel();
        delete iActiveProfileEventDelegate;
        iActiveProfileEventDelegate = NULL;
        }
    }

// -----------------------------------------------------------------------------
// CProEngNotifyHandlerImpl::CancelProfileNotifications
// -----------------------------------------------------------------------------
//
void CProEngNotifyHandlerImpl::CancelProfileNotifications( TInt aProfileId )
    {
    TInt count( iProfileEventDelegates.Count() );
    for( TInt i( 0 ); i<count; ++i )
        {
        if( iProfileEventDelegates[i]->ProfileId() == aProfileId )
            {
            CProEngProfileEventDelegate* delegate = iProfileEventDelegates[i];
            iProfileEventDelegates.Remove( i );
            delegate->Cancel();
            delete delegate;
            break;
            }
        }
    }

// -----------------------------------------------------------------------------
// CProEngNotifyHandlerImpl::CancelProfileNameArrayNotifications
// -----------------------------------------------------------------------------
//
void CProEngNotifyHandlerImpl::CancelProfileNameArrayNotifications()
    {
    if( iNameArrayEventDelegate )
        {
        iNameArrayEventDelegate->Cancel();
        delete iNameArrayEventDelegate;
        iNameArrayEventDelegate = NULL;
        }
    }

// -----------------------------------------------------------------------------
// CProEngNotifyHandlerImpl::CancelAll
// -----------------------------------------------------------------------------
//
void CProEngNotifyHandlerImpl::CancelAll()
    {
    CancelProfileActivationNotifications();
    CancelActiveProfileNotifications();
    CancelProfileNameArrayNotifications();
    TInt count = iProfileEventDelegates.Count();
    for( TInt i( 0 ); i<count; ++i )
        {
        iProfileEventDelegates[i]->Cancel();
        }
    iProfileEventDelegates.ResetAndDestroy();
    }

//  End of File