/*
* Copyright (c) 2007-2008 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:   Observes the state of a Vcc P&S property
*
*/


#include <e32cmn.h>
#include <e32debug.h>
#include <vccsubscribekeys.h>

#include "vccuipspropertylistener.h"
#include "rubydebug.h"

// ======== MEMBER FUNCTIONS ========
// -----------------------------------------------------------------------------
// C++ constructor
// -----------------------------------------------------------------------------
//
CVccUiPsPropertyListener::CVccUiPsPropertyListener( const TUint aKeyId )
    :CActive( EPriorityStandard ),
     iCategoryId( KPSVccPropertyCategory ),
     iKeyId( aKeyId )
    {
    }

// -----------------------------------------------------------------------------
// 2nd phase constructor
// -----------------------------------------------------------------------------
//
void CVccUiPsPropertyListener::ConstructL()
    {
    RUBY_DEBUG_BLOCKL( "CVccUiPsPropertyListener::ConstructL" );
    // Attach to categroy and key.
    User::LeaveIfError( iProperty.Attach( iCategoryId, iKeyId ) );
    // Add to active scheduler
    CActiveScheduler::Add( this );
    }

// -----------------------------------------------------------------------------
// Constructor
// -----------------------------------------------------------------------------
//
EXPORT_C CVccUiPsPropertyListener* CVccUiPsPropertyListener::NewL(
    const TUint aKeyId )
    {
    RUBY_DEBUG_BLOCKL( "CVccUiPsPropertyListener::NewL" );

    CVccUiPsPropertyListener* self = new ( ELeave ) CVccUiPsPropertyListener(
                                                    aKeyId );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );

    return self;
    }

// -----------------------------------------------------------------------------
// Destructor
// -----------------------------------------------------------------------------
//
EXPORT_C CVccUiPsPropertyListener::~CVccUiPsPropertyListener()
    {
    RUBY_DEBUG0( "CVccUiPsPropertyListener::~CVccUiPsPropertyListener() - ENTER" );
    Cancel();
    iProperty.Close();
    iObservers.Close();
    RUBY_DEBUG0( "CVccUiPsPropertyListener::~CVccUiPsPropertyListener() - EXIT" );
    }

// -----------------------------------------------------------------------------
// Adds a Vcc property observer to the list of observers
// -----------------------------------------------------------------------------
//
EXPORT_C void CVccUiPsPropertyListener::AddObserverL(
    MVccPsPropertyListenerObserver& aObserver )
    {
    RUBY_DEBUG_BLOCKL( "CVccUiPsPropertyListener::AddObserverL" );

    if ( iObservers.Find( &aObserver ) == KErrNotFound )
        {
        User::LeaveIfError( iObservers.Append( &aObserver ) );
        }
    
    // And then start. Start() do not start if there are no observers
    // so we must also try to start here after adding an observer
    // (if somebody has called Start() before this method).
    Start();
    }

// -----------------------------------------------------------------------------
// Removes observer
// -----------------------------------------------------------------------------
//
EXPORT_C void CVccUiPsPropertyListener::RemoveObserver(
    MVccPsPropertyListenerObserver& aObserver )
    {
    RUBY_DEBUG_BLOCK( "CVccUiPsPropertyListener::RemoveObserver" );
    TInt index = iObservers.Find( &aObserver );

    if ( index != KErrNotFound )
        {
        iObservers.Remove( index );
        }
    }

// -----------------------------------------------------------------------------
// Fetches the current value of the key
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CVccUiPsPropertyListener::CurrentValue()
    {
    RUBY_DEBUG_BLOCK( "CVccUiPsPropertyListener::CurrentValue" );
    TInt value( KErrNotFound );
    iProperty.Get( iCategoryId, iKeyId, value );
    return value;
    }

// -----------------------------------------------------------------------------
// Subscribes to property
// -----------------------------------------------------------------------------
//
EXPORT_C void CVccUiPsPropertyListener::Start()
    {
    RUBY_DEBUG_BLOCK( "CVccUiPsPropertyListener::Start" );

    // If no obsevers, do not start.
    if ( iObservers.Count() == 0 )
        {
        return;
        }
    
    // Subscribe to get updates.
    if ( !IsActive() )
        {
        iProperty.Subscribe( iStatus );       
        SetActive();
        }
    }

// -----------------------------------------------------------------------------
// Cancels the outstanding subsription request
// -----------------------------------------------------------------------------
//
void CVccUiPsPropertyListener::DoCancel()
    {
    RUBY_DEBUG0( "CVccUiPsPropertyListener::DoCancel - ENTER" );
    iProperty.Cancel();
    RUBY_DEBUG0( "CVccUiPsPropertyListener::DoCancel - EXIT" );
    }

// -----------------------------------------------------------------------------
// Handles the request completion event
// -----------------------------------------------------------------------------
//
void CVccUiPsPropertyListener::RunL()
    {
    RUBY_DEBUG_BLOCKL( "CVccUiPsPropertyListener::RunL" );
    TInt err = iStatus.Int();

    // Re-issue the subscription request if there are observers.
    // Do this before notifying our observser so that we get all
    // notifications (if the rest of the RunL takes some time).
    
    if ( iObservers.Count() > 0 )
        {
        Start();
        }
     
    if ( KErrNone == err )
        {
        // Notify property changes to observers.
        NotifyObserversL();
        }    
     }

// -----------------------------------------------------------------------------
// Notifies all observers about the changed value
// -----------------------------------------------------------------------------
//
void CVccUiPsPropertyListener::NotifyObserversL()
    {
    RUBY_DEBUG_BLOCKL( "CVccUiPsPropertyListener::NotifyObserversL" );

    TInt value = CurrentValue();

    RUBY_DEBUG1( " -value[%d]", value);

    for ( TInt i(0) ; i < iObservers.Count() ; i++ )
        {
        MVccPsPropertyListenerObserver* observer = iObservers[i];

        if ( observer )
            {
            observer->VccPropertyChangedL( iKeyId, value );
            }
        }
    }