/*

* Copyright (c) 2006-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:  Cch client api

*

*/

// INCLUDE FILES

#include "cchimpl.h"

#include "cchclientobserver.h"

#include "cchlogger.h"

#include "cchserviceimpl.h"

// EXTERNAL DATA STRUCTURES

// None

// EXTERNAL FUNCTION PROTOTYPES

// None

// CONSTANTS

// None

// MACROS

// None

// LOCAL CONSTANTS AND MACROS

// None

// MODULE DATA STRUCTURES

// None

// LOCAL FUNCTION PROTOTYPES

// None

// FORWARD DECLARATIONS

// None

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

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

// ---------------------------------------------------------------------------

// CCchClientObserver::CCchClientObserver

// C++ default constructor can NOT contain any code, that might leave.

// ---------------------------------------------------------------------------

//

CCchClientObserver::CCchClientObserver( CCchServiceImpl& aCchService )

: CActive ( EPriorityStandard )

, iCchService( aCchService )

, iBackwardSupportObserver( NULL )

    {

    CActiveScheduler::Add( this );

    }

CCchClientObserver::~CCchClientObserver()

    {

    iObservers.Reset();

    Cancel();

    }

// ---------------------------------------------------------------------------

// CCchClientObserver::ConstructL

// Symbian 2nd phase constructor can leave.

// ---------------------------------------------------------------------------

//

void CCchClientObserver::ConstructL()

    {

    CCHLOGSTRING( "CCchClientObserver::ConstructL: IN" );

    CCHLOGSTRING( "CCchClientObserver::ConstructL: OUT" );

    }

// ---------------------------------------------------------------------------

// CCchClientObserver::NewL

// Two-phased constructor.

// ---------------------------------------------------------------------------

//

CCchClientObserver* CCchClientObserver::NewL( CCchServiceImpl& aCchService )

    {

    CCHLOGSTRING( "CCchClientObserver::NewL: IN" );

    CCchClientObserver* self = 

        CCchClientObserver::NewLC( aCchService );

    CleanupStack::Pop( self );

    CCHLOGSTRING( "CCchClientObserver::NewL: OUT" );

    return self;

    }

// ---------------------------------------------------------------------------

// CCchClientObserver::NewLC

// Two-phased constructor.

// ---------------------------------------------------------------------------

//

CCchClientObserver* CCchClientObserver::NewLC( CCchServiceImpl& aCchService )

    {

    CCHLOGSTRING( "CCchClientObserver::NewLC: IN" );

    CCchClientObserver* self = 

        new (ELeave) CCchClientObserver( aCchService );

    CleanupStack::PushL( self );

    self->ConstructL();

    CCHLOGSTRING( "CCchClientObserver::NewLC: OUT" );

    return self;

    }

// ---------------------------------------------------------------------------

// CCchClientObserver::SetObserver

// ---------------------------------------------------------------------------

//

void CCchClientObserver::SetObserver( MCchServiceStatusObserver& aObserver )

    {

    CCHLOGSTRING( "CCchClientObserver::SetObserver: IN - deprecated use AddObserver" );

    // This is for old API user support remove this when all are using new API

    if( iBackwardSupportObserver )

        {

        // remove existing observer

        CCHLOGSTRING( "CCchClientObserver::SetObserver: removing old observer" );

        RemoveObserver();

        }

    CCHLOGSTRING( "CCchClientObserver::SetObserver: adding new observer" );

    // This is for old API user support remove this when all are using new API

    AddObserver( aObserver );

    iBackwardSupportObserver = &aObserver;

    CCHLOGSTRING( "CCchClientObserver::SetObserver: OUT" );

    }

// ---------------------------------------------------------------------------

// CCchClientObserver::RemoveObserver

// ---------------------------------------------------------------------------

//

void CCchClientObserver::RemoveObserver( )

    {    

    CCHLOGSTRING( "CCchClientObserver::RemoveObserver: IN - deprecated use the one with parameter" );

    if( iBackwardSupportObserver )

    	{

    	// remove using observer set in SetObserver. This is for old API user support

    	// remove this when all are using new API

    	RemoveObserver( *iBackwardSupportObserver );

    	iBackwardSupportObserver = NULL;

    	}

    CCHLOGSTRING( "CCchClientObserver::RemoveObserver: OUT" );

    }

// ---------------------------------------------------------------------------

// CCchClientObserver::AddObserver

// ---------------------------------------------------------------------------

//

TInt CCchClientObserver::AddObserver( 

    MCchServiceStatusObserver& aObserver )

    {

    CCHLOGSTRING2( "CCchClientObserver::AddObserver: IN count=%d", iObservers.Count() );

    TInt index = iObservers.Find( &aObserver );

    // Insert if not already observing

    if ( index == KErrNotFound )

        {

        CCHLOGSTRING( "CCchClientObserver::AddObserver: observer added" );

        iObservers.Append( &aObserver );

        }     

    else

        {

        CCHLOGSTRING( "CCchClientObserver::AddObserver: observer KErrAlreadyExists" );

        return KErrAlreadyExists;   

        }

    if ( iObservers.Count() )

        {

        if ( !IsActive() )

            {

            iCchService.CchImpl()->CchClient().SubscribeToEvents( 

                    TServiceSelection( iCchService.ServiceId(), ECCHUnknown ), 

                    iServiceStatus, 

                    iStatus );

            CCHLOGSTRING( "CCchClientObserver::AddObserver: setting active" );

            SetActive();

            }

        CCHLOGSTRING( "CCchClientObserver::AddObserver: subscrbing to events"  );

        }

    else

        {

        CCHLOGSTRING( "CCchClientObserver::AddObserver: already subscribed subscrbing to events - skipping"  );

        }

    CCHLOGSTRING2( "CCchClientObserver::AddObserver: OUT count=%d", iObservers.Count() );

    return KErrNone;

    }

// ---------------------------------------------------------------------------

// CCchClientObserver::RemoveObserver

// ---------------------------------------------------------------------------

//

TInt CCchClientObserver::RemoveObserver( 

    MCchServiceStatusObserver& aObserver )

    {

    CCHLOGSTRING( "CCchClientObserver::RemoveObserver: IN" );

    CCHLOGSTRING2( "CCchClientObserver::RemoveObserver IN: COUNT=%d", iObservers.Count() );

    TInt index = iObservers.Find( &aObserver );

    if ( index == KErrNotFound )

        {

        CCHLOGSTRING("CCchClientObserver::RemoveObserver - observer NOT found KErnotFound returned" );

        return KErrNotFound;   

        }

    else

        {

        CCHLOGSTRING( "CCchClientObserver::RemoveObserver: removing observer"  );

        // Observer found.

        iObservers.Remove( index );

        iObservers.Compress();

        // Cancel subcribe to events and free up memory.

        if ( !iObservers.Count() )

            {

            CCHLOGSTRING( "CCchClientObserver::RemoveObserver: unsubscrbing from events"  );                  

            iCchService.CchImpl()->CchClient().SubscribeToEventsCancel( );      

            iObservers.Reset();

            }

        }

    CCHLOGSTRING2( "CCchClientObserver::RemoveObserver OUT: COUNT=%d", iObservers.Count() );

    CCHLOGSTRING( "CCchClientObserver::RemoveObserver: OUT" );

    return KErrNone;

    }

// ---------------------------------------------------------------------------

// CCchClientObserver::DoCancel

// ---------------------------------------------------------------------------

//

void CCchClientObserver::DoCancel()

    {

    CCHLOGSTRING( "CCchClientObserver::DoCancel: IN" );

	CCHLOGSTRING( "CCchClientObserver::DoCancel: OUT" );

    }

// ---------------------------------------------------------------------------

// CCchClientObserver::RunL

// ---------------------------------------------------------------------------

//

void CCchClientObserver::RunL()

    {

    TServiceStatus serviceStatus = iServiceStatus();

    CCHLOGSTRING( "CCchClientObserver::RunL: IN" );

    //if someone is observing and correct service is changed

    if ( iObservers.Count() && ( serviceStatus.ServiceId() == iCchService.ServiceId() ) )

    	{

    	TCchServiceStatus status;

    	status.SetError( serviceStatus.iError );

    	status.SetState( serviceStatus.iState );

    	CCHLOGSTRING2( "CCchClientObserver::RunL: count=%d", iObservers.Count() );

    	// If observer array can change while iterating it add support for that.

    	// Then there is a need to iterate starting from beginning until done and save 

    	// already notified observers etc

    	TInt count( iObservers.Count() );

 	    for( TInt i=0; i < count; i++ )

            {

            CCHLOGSTRING2( "CCchClientObserver::RunL: looping observers: %d", i );

            // If some client removes observer in middle of iteration start from beginning of array again.

            if ( count > iObservers.Count() )

                {

                CCHLOGSTRING( "CCchClientObserver::RunL: Start from beginning of array" );

                i = 0;

                count = iObservers.Count();

                }

            if( iObservers[ i ] )

                {

                CCHLOGSTRING2( "CCchClientObserver::RunL: send service status changed to client: %d", i );

                iObservers[ i ]->ServiceStatusChanged( iCchService.ServiceId(), 

                    serviceStatus.Type(), status );

                }

            }

        }

    if ( iObservers.Count() )

        {

        if ( !IsActive() )

            {

            CCHLOGSTRING( "CCchClientObserver::RunL: Subscribing " );

            iCchService.CchImpl()->CchClient().SubscribeToEvents( 

                    TServiceSelection( iCchService.ServiceId(), ECCHUnknown ),

                    iServiceStatus,

                    iStatus );

            CCHLOGSTRING( "CCchClientObserver::RunL: Setting active" );

            SetActive();    

           }

        } 

    CCHLOGSTRING( "CCchClientObserver::RunL: OUT" );

    }

// ---------------------------------------------------------------------------

// CCchClientObserver::RunError

// ---------------------------------------------------------------------------

//

TInt CCchClientObserver::RunError( TInt /*aError*/ )

    {

    CCHLOGSTRING( "CCchClientObserver::RunError: IN OUT" );

    return KErrNone;

    }

// ========================== OTHER EXPORTED FUNCTIONS =========================

//  End of File