/*

* Copyright (c) 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:  Class handling the use of Cch

*

*/

#include <e32def.h>

#include <cchserver.h>

#include <cchclient.h>

#include "clogsextensioncchhandler.h"

#include "simpledebug.h"

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

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

// CLogsExtensionCchHandler::CLogsExtensionCchHandler

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

// 

CLogsExtensionCchHandler::CLogsExtensionCchHandler()

: CActive( EPriorityStandard )

    {

    }

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

// CLogsExtensionCchHandler::ConstructL

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

// 

void CLogsExtensionCchHandler::ConstructL( 

    MLogsExtensionCchHandlerObserver* aObserver,

    TUint aServiceId )

    {    

    _LOG("CLogsExtensionCchHandler::ConstructL...")

    _LOGP("...ConstructL - aServiceId: %d", aServiceId );

    iObserver = aObserver;

    // Create service selection here

    iCchClient = new ( ELeave ) RCCHClient();

    iCchServer = new ( ELeave ) RCCHServer();

    User::LeaveIfError( iCchServer->Connect() );

    User::LeaveIfError( iCchClient->Open( *iCchServer ) );

    // Add to active scheduler

    CActiveScheduler::Add( this );

    iServiceSelection.iServiceId = aServiceId;

    iServiceSelection.iType = ECCHVoIPSub;

    iCchClient->SubscribeToEvents( 

        iServiceSelection, iServiceStatus, iStatus );

    SetActive();

    }

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

// CLogsExtensionCchHandler::NewL

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

// 

CLogsExtensionCchHandler* 

    CLogsExtensionCchHandler::NewL( 

        MLogsExtensionCchHandlerObserver* aObserver,

        TUint aServiceId )

    {

    CLogsExtensionCchHandler* self = NewLC( 

        aObserver, aServiceId );

    CleanupStack::Pop( self );

    return self;

    }

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

// CLogsExtensionCchHandler::NewLC

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

// 

CLogsExtensionCchHandler* 

    CLogsExtensionCchHandler::NewLC( 

        MLogsExtensionCchHandlerObserver* aObserver,

        TUint aServiceId )

    {

    CLogsExtensionCchHandler* self =

        new ( ELeave ) CLogsExtensionCchHandler();

    CleanupStack::PushL( self );

    self->ConstructL( aObserver, aServiceId );

    return self;

    }

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

// CLogsExtensionCchHandler::~CLogsExtensionCchHandler

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

// 

CLogsExtensionCchHandler::~CLogsExtensionCchHandler()

    {

    _LOG("CLogsExtensionCchHandler::...")

    _LOG("...~CLogsExtensionCchHandler - begin")

    Cancel();

    if ( iCchClient )

        {

        iCchClient->Close();

        }

    delete iCchClient;

    iCchClient = NULL;

    if ( iCchServer )

        {

        iCchServer->Close();

        }

    delete iCchServer;

    iCchServer = NULL;

    _LOG("...~CLogsExtensionCchHandler - end")

    }

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

// CLogsExtensionCchHandler::RunL

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

// 

void CLogsExtensionCchHandler::RunL()

    {

    _LOG("CLogsExtensionCchHandler::RunL ...");

    _LOGP("...RunL - stat: %d", iStatus.Int() );

    if ( iStatus == KErrNone )  

        {

        TServiceStatus serviceStatus = iServiceStatus();

        _LOG("...RunL - Notify client")

        if ( iObserver )

            {

            iObserver->CchEventOccuredL( 

                serviceStatus.iConnectionInfo.iServiceSelection.iServiceId, 

                serviceStatus.iState,

                serviceStatus.iError );

            }

        _LOGP("...start listening again: %d", 

            serviceStatus.iConnectionInfo.iServiceSelection.iServiceId );

        }

    else 

        {

        // To be sure that event is cancelled

        DoCancel(); 

        }

    // Reissue notification request from CCH

    iCchClient->SubscribeToEvents( 

            iServiceSelection, iServiceStatus, iStatus );

    SetActive(); 

    _LOG("...RunL - out ");

    }

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

// CLogsExtensionCchHandler::DoCancel

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

// 

void CLogsExtensionCchHandler::DoCancel()

    {

    _LOG("CLogsExtensionCchHandler::DoCancel -begin")

    if ( IsActive() )

        {

        _LOG("CLogsExtensionCchHandler:: cancel events")

        iCchClient->SubscribeToEventsCancel();

        }

    _LOG("CLogsExtensionCchHandler::DoCancel -end")

    }

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

// CLogsExtensionCchHandler::RunError

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

// 

TInt CLogsExtensionCchHandler::RunError( TInt aError )

    {

    _LOG("CLogsExtensionCchHandler::RunError...");

    _LOGP("... RunError: %d", aError );

    if ( KErrServerTerminated != aError )

        {

        if ( !IsActive() )

            {

            iCchClient->SubscribeToEvents( 

                iServiceSelection, iServiceStatus, iStatus );

            SetActive();    

            }

        }

    return KErrNone;

    }

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

// CLogsExtensionCchHandler::GetServiceState

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

// 

TInt CLogsExtensionCchHandler::GetServiceState( 

    TServiceSelection aServiceSelection, 

    TCCHSubserviceState& aServiceState )

    {

    return iCchClient->GetServiceState( aServiceSelection, 

            aServiceState );

    }

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

// CLogsExtensionCchHandler::ResolveSubServiceState

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

// 

void CLogsExtensionCchHandler::ResolveSubServiceState( 

        TUint aServiceId, TInt& aCchErr )

    {

    _LOG("CLogsExtensionCchHandler::ResolveSubServiceState - begin");

    TServiceSelection serviceSelection;

    serviceSelection.iServiceId = aServiceId;

    serviceSelection.iType = ECCHPresenceSub;

    TCCHSubserviceState serviceState( 

            ECCHUninitialized );

    _LOG("...  Get Service state");

    TInt error = GetServiceState( 

        serviceSelection, serviceState );

    _LOGP("...ResolveServiceState - error: %d", error );

    _LOGP("...ResolveServiceState - service state: %d", 

        serviceState );

    aCchErr = error;

    if ( KErrNone == error &&

        serviceState != ECCHEnabled )

        {

        aCchErr = KErrNotReady;

        }

    _LOGP("...ResolveServiceState - aCchErr: %d", aCchErr );

    _LOG("CLogsExtensionCchHandler::ResolveSubServiceState - end");

    }