/*
* Copyright (c) 2007-2007 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:  CCFScriptSubscription class implementation.
*
*/



// INCLUDES
#include "cfscriptsubscription.h"
#include "cfscriptlistener.h"
#include "CFContextSubscriptionImpl.h"
#include "cftrace.h"

#include <cfcontextinterface.h>
#include <cfcontextsubscriptionlistener.h>

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

// ---------------------------------------------------------------------------
// CCFScriptSubscription::CCFScriptSubscription
// C++ default constructor can NOT contain any code, that might leave.
// ---------------------------------------------------------------------------
//
CCFScriptSubscription::CCFScriptSubscription( MCFContextInterface& aCF,
    MCFContextSubscriptionListener& aCFListener  )
    :   iCF( aCF ),
        iCFListener( aCFListener ),
        iSubscribed( EFalse )
    {
    FUNC_LOG;
    }

// ---------------------------------------------------------------------------
// CCFScriptSubscription::ConstructL
// Symbian 2nd phase constructor can leave.
// ---------------------------------------------------------------------------
//
void CCFScriptSubscription::ConstructL( MCFScriptListener* aListener )
    {
    FUNC_LOG;

    if ( !aListener )
        {
        ERROR( KErrBadHandle, "CCFScriptSubscription::ConstructL - MCFScriptListener is NULL!" );
        User::Leave( KErrBadHandle );
        }

    iSubscription = CCFContextSubscriptionImpl::NewL();
    iSubscription->SetContextSourceL( aListener->Source() );
    iSubscription->SetContextTypeL( aListener->Type() );
    iSubscription->SetSubscriptionListener( iCFListener );

    iListeners.AppendL( aListener );
    DoSubscribeL( aListener );
    }

// ---------------------------------------------------------------------------
// CCFScriptSubscription::NewL
// Two-phased constructor.
// ---------------------------------------------------------------------------
//
CCFScriptSubscription* CCFScriptSubscription::NewL( MCFContextInterface& aCF,
    MCFContextSubscriptionListener& aCFListener,
    MCFScriptListener* aListener )
    {
    FUNC_LOG;

    CCFScriptSubscription* self = NewLC( aCF, aCFListener, aListener );
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// CCFScriptSubscription::NewLC
// Two-phased constructor.
// ---------------------------------------------------------------------------
//
CCFScriptSubscription* CCFScriptSubscription::NewLC( MCFContextInterface& aCF,
    MCFContextSubscriptionListener& aCFListener,
    MCFScriptListener* aListener  )
    {
    FUNC_LOG;

    CCFScriptSubscription* self
        = new( ELeave ) CCFScriptSubscription( aCF, aCFListener );
    CleanupStack::PushL( self );
    self->ConstructL( aListener );
    return self;
    }


// Destructor
CCFScriptSubscription::~CCFScriptSubscription()
    {
    FUNC_LOG;

    if ( !iSubscribed )
        {
        delete iSubscription;
        }
    iListeners.Close();
    }


// -----------------------------------------------------------------------------
// CCFScriptSubscription::AddListenerL
// -----------------------------------------------------------------------------
//
void CCFScriptSubscription::AddListenerL( MCFScriptListener* aListener )
    {
    FUNC_LOG;

    iListeners.AppendL( aListener );
    NotifyListenerOfCurrentContextValueL( aListener );
    }

// -----------------------------------------------------------------------------
// CCFScriptSubscription::RemoveListener
// -----------------------------------------------------------------------------
//
TBool CCFScriptSubscription::RemoveListener( MCFScriptListener* aListener )
    {
    FUNC_LOG;

    TInt index = iListeners.Find( aListener );
    if ( index != KErrNotFound )
        {
        iListeners.Remove( index );
        }

    if ( iListeners.Count() == 0 )
        {
        if ( iSubscribed )
            {
            iCF.UnsubscribeContext( *iSubscription, iCFListener );
            iSubscription = NULL; // Was not owned anymore, and deleted by CF.
            iSubscribed = EFalse;
            }
        return ETrue;
        }

    return EFalse;
    }

// -----------------------------------------------------------------------------
// CCFScriptSubscription::Match
// -----------------------------------------------------------------------------
//
TBool CCFScriptSubscription::Match( const MCFScriptListener& aListener ) const
    {
    FUNC_LOG;

    if ( iSubscription->ContextSource() == aListener.Source()
        && iSubscription->ContextType() == aListener.Type() )
        {
        return ETrue;
        }

    return EFalse;
    }

// -----------------------------------------------------------------------------
// CCFScriptSubscription::Match
// -----------------------------------------------------------------------------
//
TBool CCFScriptSubscription::Match( const CCFContextObject& aContext ) const
    {
    FUNC_LOG;

    if ( iSubscription->ContextSource() == aContext.Source()
        && iSubscription->ContextType() == aContext.Type() )
        {
        return ETrue;
        }

    return EFalse;
    }

// -----------------------------------------------------------------------------
// CCFScriptSubscription::NotifyListeners
// -----------------------------------------------------------------------------
//
TBool CCFScriptSubscription::NotifyListeners( const CCFContextObject& aContext,
    TInt& aContextLevelDelay ) const
    {
    FUNC_LOG;

    TBool evaluated( EFalse );
    for ( TInt i = 0; i < iListeners.Count(); ++i )
        {
        if ( !iListeners[ i ]->IsAllRequired() )
            {
            TInt delay( 0 );
            if ( iListeners[ i ]->Evaluate( aContext, delay ) )
                {
                // Evaluation flag may not change back to false.
                evaluated = ETrue;
                }

            if ( delay > aContextLevelDelay )
                {
                aContextLevelDelay = delay;
                }
            }
        }

    return evaluated;
    }

// -----------------------------------------------------------------------------
// CCFScriptSubscription::DoSubscribeL
// Do subscribe and notify listener about current context value.
// -----------------------------------------------------------------------------
//
TInt CCFScriptSubscription::DoSubscribeL( MCFScriptListener* aListener )
    {
    FUNC_LOG;

    RThread thread;
    CleanupClosePushL( thread );                            // CLEANUP<< thread
    TInt err = iCF.SubscribeContext( iSubscription, &iCFListener, thread );
    if( err != KErrNone )
        {
        TPtrC source( aListener->Source() );
        TPtrC type( aListener->Type() );
        ERROR( err, "CCFScriptSubscription::DoSubscribeL - Subscribing context failed!" );
        ERROR_2( err, "- context source [%S], type [%S]", &source, &type );
        }
    else
        {
        iSubscribed = ETrue; // Mark successful subscription.
        NotifyListenerOfCurrentContextValueL( aListener );
        }
    CleanupStack::PopAndDestroy( &thread );                 // CLEANUP>> thread

    return err;
    }

// -----------------------------------------------------------------------------
// CCFScriptSubscription::NotifyListenerOfCurrentContextValue
// -----------------------------------------------------------------------------
//
void CCFScriptSubscription::NotifyListenerOfCurrentContextValueL(
    MCFScriptListener* aListener ) const
    {
    FUNC_LOG;

    RThread thread;
    CleanupClosePushL( thread );                            // CLEANUP<< thread
    // Request current context value for the new subscription.
    CCFContextQuery* query = CCFContextQuery::NewLC();      // CLEANUP<< query
    RContextObjectArray results; // Pointers not owned.
    CleanupClosePushL( results );                           // CLEANUP<< results
    query->SetSourceL( iSubscription->ContextSource() );
    query->SetTypeL( iSubscription->ContextType() );

    iCF.RequestContext( results, *query, thread );
    if ( results.Count() )
        {
        CCFContextObject* context = results[ 0 ];
        TInt delay( 0 ); // Required by the call but not used.
        aListener->Evaluate( *context, delay );
        }

    CleanupStack::PopAndDestroy( &results );                // CLEANUP>> results
    CleanupStack::PopAndDestroy( query );                   // CLEANUP>> query
    CleanupStack::PopAndDestroy( &thread );                 // CLEANUP>> thread
    }