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


// INCLUDE FILES
#include "cchimpl.h"
#include "cchlogger.h"
#include "cch.h"
#include "cchserviceimpl.h"

#ifdef CCHAPI_USE_CCHUI
#include "cchuiprivateapi.h"
#endif

// 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 =============================

// ---------------------------------------------------------------------------
// CCchImpl::CCchImpl
// C++ default constructor can NOT contain any code, that might leave.
// ---------------------------------------------------------------------------
//
CCchImpl::CCchImpl()
     : CActive ( EPriorityStandard ),
       iCchUi(0), 
       iConnectivityDialogsAllowed( EFalse )
	{
	CActiveScheduler::Add( this );
    }

// ---------------------------------------------------------------------------
// CCchImpl::destructor
// ---------------------------------------------------------------------------
//    
CCchImpl::~CCchImpl()
    {
    CCHLOGSTRING( "CCchImpl::~CCchImpl: IN" );
    
    delete iCchUi;

    iCchServiceImpls.ResetAndDestroy();
    iCchServiceImpls.Close();
    Cancel();
    
    iCchClient.Close();
    iCchServer.Close();
    
    CCHLOGSTRING( "CCchImpl::~CCchImpl: OUT" );
    }

// ---------------------------------------------------------------------------
// CCchImpl::ConstructL
// Symbian 2nd phase constructor can leave.
// ---------------------------------------------------------------------------
//
void CCchImpl::ConstructL( CCch& aCch )
    {
    CCHLOGSTRING( "CCchImpl::ConstructL: IN" );

    User::LeaveIfError( iCchServer.Connect() );
    User::LeaveIfError( iCchClient.Open( iCchServer ) );

#ifdef CCHAPI_USE_CCHUI
    iCchUi = CCchUiPrivateApi::NewL( aCch );
#endif

    iCchClient.RegisterToServer( iStatus );
    SetActive();
    
    CCHLOGSTRING( "CCchImpl::ConstructL: OUT" );
    }

// ---------------------------------------------------------------------------
// CCchImpl::NewL
// Two-phased constructor.
// ---------------------------------------------------------------------------
//
CCchImpl* CCchImpl::NewL( CCch& aCch )
    {
    CCHLOGSTRING( "CCchImpl::NewL: IN" );
    CCchImpl* self = 
        CCchImpl::NewLC( aCch );
    CleanupStack::Pop( self );
    CCHLOGSTRING( "CCchImpl::NewL: OUT" );
    return self;
    }

// ---------------------------------------------------------------------------
// CCchImpl::NewLC
// Two-phased constructor.
// ---------------------------------------------------------------------------
//
CCchImpl* CCchImpl::NewLC( CCch& aCch )
    {
    CCHLOGSTRING( "CCchImpl::NewLC: IN" );
    CCchImpl* self = 
        new (ELeave) CCchImpl( );
    CleanupStack::PushL( self );
    self->ConstructL( aCch );
    CCHLOGSTRING( "CCchImpl::NewLC: OUT" );
    return self;
    }

// ---------------------------------------------------------------------------
// CCchImpl::NewLC
// Returns the RCCHClient 
// ---------------------------------------------------------------------------
//
RCCHClient& CCchImpl::CchClient( )
	{
	CCHLOGSTRING( "CCchImpl::CchClient: IN OUT" );
	return iCchClient;
	}

// ---------------------------------------------------------------------------
// CCchImpl::GetService
// ---------------------------------------------------------------------------
//
CCchService* CCchImpl::GetService( TInt aId )
	{
	CCHLOGSTRING( "CCchImpl::GetService: IN" );
	
	CCchServiceImpl* cchServiceImpl = NULL;
	
	TInt idx = FindService( aId );
	if( idx == KErrNotFound )
		{
		TInt error = KErrNone;
	    TRAP( error, cchServiceImpl = GetServiceL( aId ) );
		}
	else
		{
		cchServiceImpl = iCchServiceImpls[ idx ];
		}
	CCHLOGSTRING( "CCchImpl::GetService: OUT" );
	return cchServiceImpl;
	}

// ---------------------------------------------------------------------------
// CCchImpl::GetServiceL
// ---------------------------------------------------------------------------
//
CCchServiceImpl* CCchImpl::GetServiceL( TInt aId )
	{
	CCchServiceImpl* cchServiceImpl = NULL;	
	
	CArrayFixFlat<TCCHService>* cchServices =
		new ( ELeave ) CArrayFixFlat<TCCHService>( 1 );
	CleanupStack::PushL( cchServices );
	if( KErrNone == GetCchServicesL( aId, ECCHUnknown , *cchServices ) )
		{
		if( cchServices->Count() )
		    {
    		TCCHService service = cchServices->At( 0 );
    		cchServiceImpl = CCchServiceImpl::NewL( *this, 
    		                                        service.iServiceId, 
    		                                        *iCchUi );
    		
    		TInt error = iCchServiceImpls.Append( cchServiceImpl );
    		if( error == KErrNone )
    			{
    			cchServiceImpl = iCchServiceImpls[ iCchServiceImpls.Count() - 1 ];
    			}
    		else
    			{
    			delete cchServiceImpl;
    			cchServiceImpl = NULL;
    			}
		    }
		}
	cchServices->Reset();
	CleanupStack::PopAndDestroy( cchServices );
	return cchServiceImpl;
	}


// ---------------------------------------------------------------------------
// CCchImpl::GetCchServiceL
// ---------------------------------------------------------------------------
//
TInt CCchImpl::GetCchServicesL( TInt aServiceId, TCCHSubserviceType aType, 
								CArrayFixFlat<TCCHService>& aServices )
	{
	TServiceSelection selection( aServiceId, aType, ECchInitial  );
    TRequestStatus status = KErrNone;

    iCchClient.GetServicesL( selection, aServices, status );			
	//even the cchclient api seems to be asynchronous, 
	//this method is completed immediately
	User::WaitForRequest( status );
	return status.Int();
	}
	
// ---------------------------------------------------------------------------
// CCchImpl::GetServiceIdsL
// ---------------------------------------------------------------------------
//
void CCchImpl::GetServiceIdsL( RArray<TInt>& aIds )
    {
	CCHLOGSTRING( "CCchImpl::GetServiceIdsL: IN" );

	TRequestStatus status( KErrNone );
    CArrayFixFlat<TCCHService>* cchServices = new (ELeave) CArrayFixFlat<TCCHService>(1);
    CleanupStack::PushL( cchServices );

    iCchClient.GetServicesL( *cchServices, status );
	    
	//even the cchclient api seems to be asynchronous, 
	//this method is completed immediately	
	User::WaitForRequest( status );
	if( KErrNone == status.Int() )
		{
		for ( TInt i = 0; i < cchServices->Count(); i++ )
			{
			TCCHService service = cchServices->At( i );
			User::LeaveIfError( aIds.Append( service.iServiceId ) );
			}
		}
	else
		{
		User::Leave( status.Int() );
		}	
    CleanupStack::PopAndDestroy( cchServices );

	CCHLOGSTRING( "CCchImpl::GetServiceIdsL: OUT" );
    }
    
// ---------------------------------------------------------------------------
// CCchImpl::GetServiceIds
// ---------------------------------------------------------------------------
//
TInt CCchImpl::GetServiceIds( RArray<TInt>& aIds )
	{
	TRAPD( err, GetServiceIdsL( aIds ) );
	
	return err;
	}

// ---------------------------------------------------------------------------
// CCchImpl::GetServices
// ---------------------------------------------------------------------------
//
TInt CCchImpl::GetServices( TCCHSubserviceType aType, 
        RPointerArray<CCchService>& aServices )
	{
	TInt err = KErrNone;
	TRAP( err, GetServicesL( aType, aServices ) );
	return err;
	}

// ---------------------------------------------------------------------------
// CCchImpl::GetServicesL
// ---------------------------------------------------------------------------
//
void CCchImpl::GetServicesL( TCCHSubserviceType aType, 
        RPointerArray<CCchService>& aServices )
    {
    CCHLOGSTRING( "CCchImpl::GetServicesL: IN" );

    CleanupClosePushL( aServices );  // CS: 1
    
    TInt error = KErrNone;
    TServiceSelection selection( 0, aType, ECchInitial );

    CCchServiceImpl* cchServiceImpl = NULL;
    CArrayFixFlat<TCCHService>* cchServices;
    cchServices = new (ELeave) CArrayFixFlat<TCCHService>(1);
    CleanupStack::PushL( cchServices );  // CS: 2
    error = GetCchServicesL( 0, aType, *cchServices );
    
    if( KErrNone == error )
        {
        for ( TInt i = 0; i < cchServices->Count(); i++ )
            {
            TCCHService service = cchServices->At( i );
            TInt idx = FindService( service.iServiceId );
            
            if( KErrNotFound == idx )
                {
                cchServiceImpl = CCchServiceImpl::NewLC( *this, // CS: 3
                    service.iServiceId, *iCchUi );
                iCchServiceImpls.AppendL( cchServiceImpl );
                CleanupStack::Pop( cchServiceImpl );  // CS: 2
                }
            else
                {
                cchServiceImpl = iCchServiceImpls[ idx ];
                }
            
            aServices.AppendL( cchServiceImpl );
            }
        }
    
    cchServices->Reset();
    CleanupStack::PopAndDestroy( cchServices );  // CS: 1
    User::LeaveIfError( error );
    CleanupStack::Pop( &aServices );  // CS: 0
    
    CCHLOGSTRING( "CCchImpl::GetServicesL: OUT" );
    }

// ---------------------------------------------------------------------------
// CCCHServiceHandler::FindService
// ---------------------------------------------------------------------------
//
TInt CCchImpl::FindService( TInt aServiceId ) const
    {
    TBool exist = EFalse;
    TInt index = KErrNotFound;
    CCHLOGSTRING2( "CCchImpl::FindService: serviceId %d", aServiceId );
    for ( TInt i = 0; i < iCchServiceImpls.Count() && !exist; i++ )
        {
        exist = iCchServiceImpls[i]->ServiceId() == aServiceId;
        index = i;
        }
    return !exist ? KErrNotFound : index;
    }

// ---------------------------------------------------------------------------
// CCCHServiceHandler::ConnectivityDialogsAllowed
// ---------------------------------------------------------------------------
//
TBool CCchImpl::ConnectivityDialogsAllowed() const
    {
    CCHLOGSTRING( "CCchImpl::ConnectivityDialogsAllowed" );
    CCHLOGSTRING2( "  --> iConnectivityDialogsAllowed=%d", 
        iConnectivityDialogsAllowed );
    
    return iConnectivityDialogsAllowed;
    }

// ---------------------------------------------------------------------------
// CCCHServiceHandler::SetConnectivityDialogsAllowed
// ---------------------------------------------------------------------------
//
void CCchImpl::SetConnectivityDialogsAllowed( 
    TBool aConnectivityDialogsAllowed )
    {
    iConnectivityDialogsAllowed = aConnectivityDialogsAllowed;
    }

// ---------------------------------------------------------------------------
// CCCHServiceHandler::CchUiApi
// ---------------------------------------------------------------------------
//
MCchUi& CCchImpl::CchUiApi() const
    {
    return *iCchUi;
    }

// ---------------------------------------------------------------------------
// CCchImpl::DoCancel
// ---------------------------------------------------------------------------
//
void CCchImpl::DoCancel()
    {
    CCHLOGSTRING( "CCchImpl::DoCancel: IN" );
	iCchClient.RegisterToServerCancel();
	CCHLOGSTRING( "CCchImpl::DoCancel: OUT" );
    }

// ---------------------------------------------------------------------------
// CCchImpl::RunL
// ---------------------------------------------------------------------------
//
void CCchImpl::RunL()
    {
    CCHLOGSTRING( "CCchImpl::RunL: IN" );
    if ( iStatus.Int() == KErrServerTerminated )
        {
        // clean
        Cancel();
        iCchClient.Close();
        iCchServer.Close();
        
        // create new
        User::LeaveIfError( iCchServer.Connect() );
        User::LeaveIfError( iCchClient.Open( iCchServer ) );

        iCchClient.RegisterToServer( iStatus );
        SetActive();
        }
    CCHLOGSTRING( "CCchImpl::RunL: OUT" );
    }
    
// ---------------------------------------------------------------------------
// CCchImpl::RunL
// ---------------------------------------------------------------------------
//
TInt CCchImpl::RunError( TInt /*aError*/ )
    {
    return KErrNone;
    }    

//  End of File