/*
* Copyright (c) 2007-2010 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:  For handling interactions betweed UI and CCH.
*
*/


#include <cch.h>

#include "cscenglogger.h"
#include "cscengcchhandler.h"
#include "mcscengcchobserver.h"

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

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
CCSCEngCCHHandler::CCSCEngCCHHandler( MCSCEngCCHObserver& aObserver ) :
    iObserver( aObserver )
    {    
    }


// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
void CCSCEngCCHHandler::ConstructL()
    {
    CSCENGDEBUG( "CCSCEngCCHHandler::ConstructL - begin" ); 
    
    iCchClientApi = CCch::NewL();
    
    CSCENGDEBUG( "CCSCEngCCHHandler::ConstructL - end" ); 
    }   
    
    
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
EXPORT_C CCSCEngCCHHandler* CCSCEngCCHHandler::NewL( 
    MCSCEngCCHObserver& aObserver )
    {    
    CCSCEngCCHHandler* self = new ( ELeave ) CCSCEngCCHHandler( aObserver );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }


// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
CCSCEngCCHHandler::~CCSCEngCCHHandler()
    {
    CSCENGDEBUG( "CCSCEngCCHHandler::~CCSCEngCCHHandler - begin" ); 
    
    delete iCchClientApi;    
    
    CSCENGDEBUG( "CCSCEngCCHHandler::~CCSCEngCCHHandler - end" ); 
    }


// ---------------------------------------------------------------------------
// Disable service.
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CCSCEngCCHHandler::DisableService( TInt aServiceId )
    {    
    CCchService* service = iCchClientApi->GetService( aServiceId );
    
    TInt err( KErrNone );
    if ( service )
        {
        service->SetObserver( *this );
        err = service->Disable( ECCHUnknown );
        }
    else
        {
        err = KErrArgument;
        }
    
    return err;
    }


// ---------------------------------------------------------------------------
// Check is service disabled
// ---------------------------------------------------------------------------
//
EXPORT_C TBool CCSCEngCCHHandler::IsServiceDisabled( TInt aServiceId )
    {    
    TBool disabled( ETrue );

    if ( !IsDisabled( aServiceId, ECCHVoIPSub ) ) return EFalse;
    if ( !IsDisabled( aServiceId, ECCHPresenceSub ) ) return EFalse;
    if ( !IsDisabled( aServiceId, ECCHIMSub ) ) return EFalse;      
    if ( !IsDisabled( aServiceId, ECCHVMBxSub ) ) return EFalse;
        
    return disabled;
    }

// ---------------------------------------------------------------------------
// Check is service is valid
// ---------------------------------------------------------------------------
//
EXPORT_C TBool CCSCEngCCHHandler::IsServiceValidL( TInt aServiceId )
    {    
    TBool validService( EFalse );
    
    TSupportedSubServices supportedSubServices;
    SupportedSubServicesL( aServiceId, supportedSubServices );

    // Service is valid if some subservice is supported
    if ( supportedSubServices.iVoIP || supportedSubServices.iIm ||
        supportedSubServices.iPresence || supportedSubServices.iVmbx )
        {
        validService = ETrue;
        }
    
    return validService;
    }

// ---------------------------------------------------------------------------
// Get supported subservices.
// ---------------------------------------------------------------------------
//
EXPORT_C void CCSCEngCCHHandler::SupportedSubServicesL( 
    TInt aServiceId, TSupportedSubServices& aSupSubServices )
    {
    // Create new cch client for access the latest service info data.
    CCchService* service = 
        CCch::NewLC()->GetService( aServiceId );

    TBool supported( EFalse );
    
    if ( service )
        {
        service->IsSupported( ECCHVoIPSub, supported );
        aSupSubServices.iVoIP = supported;
        
        service->IsSupported( ECCHPresenceSub, supported );
        aSupSubServices.iPresence = supported;
        
        service->IsSupported( ECCHIMSub, supported );
        aSupSubServices.iIm = supported;
        
        service->IsSupported( ECCHVMBxSub, supported );
        aSupSubServices.iVmbx = supported;
        }
    
    CleanupStack::PopAndDestroy(); // cch
    
    CSCENGDEBUG2( 
            "CCSCEngCCHHandler::SupportedSubServicesL VoIP=%d", 
                aSupSubServices.iVoIP );
    CSCENGDEBUG2( 
            "CCSCEngCCHHandler::SupportedSubServicesL Presence=%d", 
                aSupSubServices.iPresence );
    CSCENGDEBUG2( 
            "CCSCEngCCHHandler::SupportedSubServicesL IM=%d", 
                aSupSubServices.iIm );
    CSCENGDEBUG2( 
            "CCSCEngCCHHandler::SupportedSubServicesL VMBX=%d", 
                aSupSubServices.iVmbx );
    }

// ---------------------------------------------------------------------------
// Get cch connection parameter (RBuf).
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CCSCEngCCHHandler::GetConnectionParameter( 
    TInt aServiceId, 
    TCchConnectionParameter aConnParam,
    RBuf& aConnParamValue )
    {   
    CSCENGDEBUG(  "CCSCEngCCHHandler::GetConnectionParameter" );
    
    CCchService* service = 
           iCchClientApi->GetService( aServiceId );

    TInt err( KErrNone );
    if ( service )
        {
        err = service->GetConnectionParameter( 
            ECCHUnknown, aConnParam, aConnParamValue );
        }
    else
        {
        err = KErrArgument;
        }
    
    return err;
    }


// ---------------------------------------------------------------------------
// Get cch connection parameter (TInt).
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CCSCEngCCHHandler::GetConnectionParameter( 
    TInt aServiceId, 
    TCchConnectionParameter aConnParam,
    TInt& aConnParamValue )
    {   
    CSCENGDEBUG(  "CCSCEngCCHHandler::GetConnectionParameter" );
    
    CCchService* service = 
           iCchClientApi->GetService( aServiceId );

    
    TInt err( KErrNone );
    if ( service )
        {
        err = service->GetConnectionParameter( 
            ECCHUnknown, aConnParam, aConnParamValue );
        }
    else
        {
        err = KErrArgument;
        }
        
    return err;
    }


// ---------------------------------------------------------------------------
// Set cch connection parameter.
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CCSCEngCCHHandler::SetConnectionParameter( 
    TInt aServiceId,
    TCchConnectionParameter aConnParam,
    const TDesC& aConnParamValue )
    {       
    CSCENGDEBUG(  "CCSCEngCCHHandler::SetConnectionParameter" );
    
    CCchService* service = 
           iCchClientApi->GetService( aServiceId );
    
    TInt err( KErrNone );
    if ( service )
        {
        err =service->SetConnectionParameter( 
            ECCHUnknown, aConnParam, aConnParamValue );
        }
    else
        {
        err = KErrArgument;
        }
           
    return err;
    }

// ---------------------------------------------------------------------------
// CCSCEngCCHHandler::IsDisabled
// ---------------------------------------------------------------------------
//
TBool CCSCEngCCHHandler::IsDisabled( 
    TInt aServiceId, 
    TCCHSubserviceType aType  )                                     
    {                                                                                                          
    TBool disabled( EFalse );                                                                                   
    
    CCchService* service = 
          iCchClientApi->GetService( aServiceId );
    
    if ( service )
        {
        TCchServiceStatus status;
        TInt err = service->GetStatus( aType, status );
                                                                                                                                                                                       
        if ( KErrNotFound == err || 
             ( KErrNone == err && 
             ( ECCHUninitialized == status.State() || 
               ECCHDisabled == status.State() ) ) )
            {                                                                                                                                         
            disabled = ETrue;                                                                                                                        
            }          
        }

    return disabled;                                                                                                              
    }  
    
// ---------------------------------------------------------------------------
// From class MCchServiceStatusObserver
// ---------------------------------------------------------------------------
//
void CCSCEngCCHHandler::ServiceStatusChanged( 
    TInt aServiceId, 
    TCCHSubserviceType aType, 
    const TCchServiceStatus& aServiceStatus )                  
    {       
    CSCENGDEBUG(  "CCSCEngCCHHandler::ServiceStatusChanged" );
    
    if ( ECCHDisabled == aServiceStatus.State() )
        {
        CCchService* service = 
                  iCchClientApi->GetService( aServiceId );
        
        if ( service )
            {
            service->RemoveObserver();
            }
        }
    
    iObserver.ServiceStatusChanged(
            aServiceId, 
            aType, 
            aServiceStatus );                                                                                   
    }