/*
* Copyright (c) 2008-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:
*
* Description:  This implements CListener class.
*
*/


// INCLUDE FILES
#include "listener.h"
#include "mpropertyobserver.h"
#include "harvesterlog.h" // For debugging.

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

// -----------------------------------------------------------------------------
// CListener::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CListener* CListener::NewL( const TUid aPropertyCategory,
		const TUint aKey )
    {
    WRITELOG( "CListener::NewL() - begin" );
    
    CListener* self = CListener::NewLC( aPropertyCategory, aKey );
    CleanupStack::Pop( self );
    
    WRITELOG( "CListener::NewL() - end" );
    return self;
    }

// -----------------------------------------------------------------------------
// CListener::NewLC
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CListener* CListener::NewLC( const TUid aPropertyCategory,
		const TUint aKey )
    {
    WRITELOG( "CHarvesterAO::NewLC() - begin" );
    
    CListener* self = new ( ELeave ) CListener( aPropertyCategory, aKey );
    CleanupStack::PushL( self );
    self->ConstructL();
    
    WRITELOG( "CListener::NewLC - end" );
    return self;
    }

// -----------------------------------------------------------------------------
// CListener::~CListener
// C++ default destructor
// -----------------------------------------------------------------------------
//    
CListener::~CListener()
    {
    WRITELOG( "CListener::~CListener - begin" );
    
    Cancel(); // Cancels any existing active object orders for iStatus.
    
    iProperty.Close();
    
    iArrayForKeyValue.Reset();
    iArrayForKeyValue.Close();
    
    iArrayForKeyAndStatus.Reset();
    iArrayForKeyAndStatus.Close();

    WRITELOG( "CListener::~CListener - end" );   
    }

// -----------------------------------------------------------------------------
// CListener::ObservedKey
// Returns observed key.
// -----------------------------------------------------------------------------
//
TUint CListener::ObservedKey() const
    {
    WRITELOG( "CListener::ObservedKey" );
    
    return iKey; 
    }

// -----------------------------------------------------------------------------
// CListener::ObservedCategory
// Returns observed key's Category.
// -----------------------------------------------------------------------------
//
TUid CListener::ObservedCategory() const
    {
    WRITELOG( "CListener::ObservedCategory" );
    
    return iPropertyCategory; 
    }

// -----------------------------------------------------------------------------
// CListener::RegisterNewClientForKeyValueL
// 
// -----------------------------------------------------------------------------
//
void CListener::RegisterNewClientForKeyValueL( const MKeyObserver* aKeyObserver )
    {
    WRITELOG( "CListener::RegisterNewClientForKeyValue" );
    
    User::LeaveIfError( iArrayForKeyValue.Append( aKeyObserver ) );
    }

// -----------------------------------------------------------------------------
// CListener::RegisterNewClientForKeyAndStatusL
// 
// -----------------------------------------------------------------------------
//
void CListener::RegisterNewClientForKeyAndStatusL( 
		const MKeyAndStatusObserver* aKeyAndStatusObserver )
    {
    WRITELOG( "CListener::RegisterNewClientForKeyAndStatus" );
    
    User::LeaveIfError( iArrayForKeyAndStatus.Append( aKeyAndStatusObserver ) );
    }

// -----------------------------------------------------------------------------
// CListener::UnregisterKeyClient
//
// -----------------------------------------------------------------------------
//
void CListener::UnregisterKeyClient( const MKeyObserver* aKeyObserver )
    {
    WRITELOG( "CListener::RemoveClient - begin" ); 
    
    const TInt listIndex = iArrayForKeyValue.Find( aKeyObserver );
    if( listIndex != KErrNotFound )
    	{
    	iArrayForKeyValue.Remove( listIndex );
    	}
 
    WRITELOG( "CListener::RemoveClient - end" );   
    }

// -----------------------------------------------------------------------------
// CListener::UnregisterKeyAndStatusClient
//
// -----------------------------------------------------------------------------
//
void CListener::UnregisterKeyAndStatusClient( const MKeyAndStatusObserver* aKeyAndStatusObserver )
    {
    WRITELOG( "CListener::UnregisterKeyAndStatusClient - begin" ); 
    
    const TInt listIndex = iArrayForKeyAndStatus.Find( aKeyAndStatusObserver );
    if( listIndex != KErrNotFound )
    	{
    	iArrayForKeyAndStatus.Remove( listIndex );
    	}
 
    WRITELOG( "CListener::UnregisterKeyAndStatusClient - end" );   
    }

// -----------------------------------------------------------------------------
// CListener::CListener
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CListener::CListener( const TUid aPropertyCategory, const TUint aKey ) :
		CActive( CActive::EPriorityUserInput ),
		iPropertyCategory( aPropertyCategory ),
		iKey( aKey )
 	{
 	// No implementation required.
 	}

// -----------------------------------------------------------------------------
// CListener::ConstructL
// Construct member variable that is to access the
// kernel. 
// -----------------------------------------------------------------------------
//
void CListener::ConstructL()
    {
    WRITELOG( "CListener::ConstructL - begin" );
    
    CActiveScheduler::Add( this );
    
	// Attach to key.
 	User::LeaveIfError( iProperty.Attach( 
 			iPropertyCategory,
 			iKey,
 			EOwnerThread ) );
 	
 	// Sets object active.
	StartListening();
    
    WRITELOG( "CListener::ConstructL - end" );
    }

// -----------------------------------------------------------------------------
// CListener::RunL
// This function will be called upon a change in the watched key.
// From class CActive.
// -----------------------------------------------------------------------------
//
void CListener::RunL()
    {
#ifdef _DEBUG
    WRITELOG1( "CListener::RunL - begin, iStatus: %d",  iStatus.Int() ); 
#endif
    
    if( iStatus.Int() == KErrNone )
    	{
    	TInt keyValue( KErrNone );
    	User::LeaveIfError( iProperty.Get( keyValue ) );
    	SendNotificationsL( keyValue, iStatus );
    	}
    
    // Start listening again.
    StartListening();
    
    WRITELOG( "CListener::RunL - end" );
    }

// -----------------------------------------------------------------------------
// CListener::RunError
// Standard active object error function. From class CActive.
// -----------------------------------------------------------------------------
//
#ifdef _DEBUG
TInt CListener::RunError( TInt aError )
#else
TInt CListener::RunError( TInt /*aError*/ )
#endif
    {
    WRITELOG1( "CListener::RunError, aError: %d",  aError );
    
    Cancel();
    
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CListener::DoCancel
// Standard active object cancellation function. From class CActive.
// -----------------------------------------------------------------------------
//
void CListener::DoCancel()
    {
    WRITELOG( "CListener::DoCancel" );
    
    iProperty.Cancel();	
    }

// -----------------------------------------------------------------------------
// CListener::StartListeningL
// Then start listening of the changes in the key.
// -----------------------------------------------------------------------------
//
void CListener::StartListening()
    {
    WRITELOG( "CListener::StartListeningL - begin" ); 
    
    if( IsActive() )
        {
        return;   
        }

	iProperty.Subscribe( iStatus );
	SetActive();
 
   WRITELOG( "CListener::StartListeningL - end" );   
   }

// -----------------------------------------------------------------------------
// CListener::SendNotificationsL
// Send notifications to clients.
// -----------------------------------------------------------------------------
//
void CListener::SendNotificationsL( const TUint aKeyValue,
		TRequestStatus& aStatus ) const 
    {
    WRITELOG( "CListener::SendNotifications - begin" ); 
    
    // For value only.
    for ( TInt i = iArrayForKeyValue.Count(); --i >= 0; ) 
    	{
        iArrayForKeyValue[i]->NotifyKeyL(
        		aKeyValue,
        		iPropertyCategory,
        		iKey );
        }
    
    // For status and value.
    for ( TInt i = iArrayForKeyAndStatus.Count(); --i >= 0; ) 
    	{
        iArrayForKeyAndStatus[i]->NotifyKeyAndStatusL( 
        		aKeyValue,
        		aStatus,
        		iPropertyCategory,
        		iKey );
        }

    WRITELOG( "CListener::SendNotifications - end" );   
    }

// End of file.