/*

* Copyright (c) 2005-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:   

* System Includes

*

*/

#include <stdio.h>

#include <assert.h>

#include <rpc/types.h>

/****************************************************************************************

 * 

 * Local Includes

 * 

 ***************************************************************************************/

#include "CCGpssimulator.h"

/****************************************************************************************

 * 

 * Implementation

 * 

 ***************************************************************************************/

CCGpssimulator::CCGpssimulator()

{

	cl = NULL;

	iLastRPCError.re_status = RPC_SUCCESS;

}

CCGpssimulator::~CCGpssimulator()

{

	assert( cl == NULL );

}

char *CCGpssimulator::GetLastRPCError( int *aIntErr )

{

	struct rpc_err rpcerr;

	// check that the handle is valid

	if( cl == NULL ) {

		return NULL;

	}

	// pass the aIntErr

	if( aIntErr != NULL ) {

		clnt_geterr( cl, &rpcerr );

		*aIntErr = rpcerr.re_status;

	}

	// return the errorstring

	return clnt_sperror( cl, NULL );

}

int CCGpssimulator::Connect( string aRemoteHost )

{

	// check that we are not already connected

	if( cl != NULL ) {

		return ERR_STUB_ALREADY_CONNECTED;

	}

	// start the rpc library

	rpc_nt_init();

	// connect to the service

	cl = clnt_create( aRemoteHost.c_str(), GPSSIMULATOR, GPSSIMULATOR_VERSION, "tcp" );

	if( cl == NULL ) {

		rpc_nt_exit();

		return ERR_FAILED_TO_CONNECT;

	}

	// done

	return ERR_NONE;

}

int CCGpssimulator::Disconnect( )

{

	// check that we are connected

	if( cl == NULL ) {

		return ERR_STUB_NOT_CONNECTED;

	}

	// cleanup the client handle

	clnt_destroy( cl );

	cl = NULL;

	rpc_nt_exit();

	// done

	return ERR_NONE;

}

/****************************************************************************************

 * 

 * PUBLIC FUNCTION: ss_startuprpcservice

 * 

 ***************************************************************************************/

int CCGpssimulator::ss_startuprpcservice( TStartupInfo aArgs, int *rv )

{

	struct rpc_err rerr;

	// check the rv pointer

	if( rv == NULL ) {

		return ERR_INVALID_RV_POINTER;

	}

	// check that we have a connection

	if( cl == NULL ) {

		return ERR_STUB_NOT_CONNECTED;

	}

	// do the call

	*rv = *ss_startuprpcservice_10( &aArgs, cl );

	// check for rpc errors and return the result

	clnt_geterr( cl, &rerr );

	if( rerr.re_status != RPC_SUCCESS ) {

		iLastRPCError = rerr;

		return ERR_RPC_ERROR;

	}

	return ERR_NONE;

}

/****************************************************************************************

 * 

 * PUBLIC FUNCTION: sc_shutdownrpcservice

 * 

 ***************************************************************************************/

int CCGpssimulator::sc_shutdownrpcservice( int aArgs, int *rv )

{

	struct rpc_err rerr;

	// check the rv pointer

	if( rv == NULL ) {

		return ERR_INVALID_RV_POINTER;

	}

	// check that we have a connection

	if( cl == NULL ) {

		return ERR_STUB_NOT_CONNECTED;

	}

	// do the call

	*rv = *sc_shutdownrpcservice_10( &aArgs, cl );

	// check for rpc errors and return the result

	clnt_geterr( cl, &rerr );

	if( rerr.re_status != RPC_SUCCESS ) {

		iLastRPCError = rerr;

		return ERR_RPC_ERROR;

	}

	return ERR_NONE;

}

/****************************************************************************************

 * 

 * PUBLIC FUNCTION: list_connections

 * 

 ***************************************************************************************/

int CCGpssimulator::list_connections( TComponentList *rv )

{

	struct rpc_err rerr;

	int aArgs = 0;

	// check the rv pointer

	if( rv == NULL ) {

		return ERR_INVALID_RV_POINTER;

	}

	// check that we have a connection

	if( cl == NULL ) {

		return ERR_STUB_NOT_CONNECTED;

	}

	// do the call

	*rv = *list_connections_1( &aArgs, cl );

	// check for rpc errors and return the result

	clnt_geterr( cl, &rerr );

	if( rerr.re_status != RPC_SUCCESS ) {

		iLastRPCError = rerr;

		return ERR_RPC_ERROR;

	}

	return ERR_NONE;

}

/****************************************************************************************

 * 

 * PUBLIC FUNCTION: cstr_startprocess

 * 

 ***************************************************************************************/

int CCGpssimulator::cstr_startprocess( char *aArgs, int *rv )

{

	struct rpc_err rerr;

	// check the rv pointer

	if( rv == NULL ) {

		return ERR_INVALID_RV_POINTER;

	}

	// check that we have a connection

	if( cl == NULL ) {

		return ERR_STUB_NOT_CONNECTED;

	}

	// do the call

	*rv = *cstr_startprocess_1( &aArgs, cl );

	// check for rpc errors and return the result

	clnt_geterr( cl, &rerr );

	if( rerr.re_status != RPC_SUCCESS ) {

		iLastRPCError = rerr;

		return ERR_RPC_ERROR;

	}

	return ERR_NONE;

}

/****************************************************************************************

 * 

 * PUBLIC FUNCTION: dstr_removeprocess

 * 

 ***************************************************************************************/

int CCGpssimulator::dstr_removeprocess( int aArgs, int *rv )

{

	struct rpc_err rerr;

	// check the rv pointer

	if( rv == NULL ) {

		return ERR_INVALID_RV_POINTER;

	}

	// check that we have a connection

	if( cl == NULL ) {

		return ERR_STUB_NOT_CONNECTED;

	}

	// do the call

	*rv = *dstr_removeprocess_1( &aArgs, cl );

	// check for rpc errors and return the result

	clnt_geterr( cl, &rerr );

	if( rerr.re_status != RPC_SUCCESS ) {

		iLastRPCError = rerr;

		return ERR_RPC_ERROR;

	}

	return ERR_NONE;

}

/****************************************************************************************

 * 

 * PUBLIC FUNCTION: startsimulator

 * 

 ***************************************************************************************/

int CCGpssimulator::startsimulator( int *rv )

{

	struct rpc_err rerr;

	int aArgs = 0;

	// check the rv pointer

	if( rv == NULL ) {

		return ERR_INVALID_RV_POINTER;

	}

	// check that we have a connection

	if( cl == NULL ) {

		return ERR_STUB_NOT_CONNECTED;

	}

	// do the call

	*rv = *startsimulator_1( &aArgs, cl );

	// check for rpc errors and return the result

	clnt_geterr( cl, &rerr );

	if( rerr.re_status != RPC_SUCCESS ) {

		iLastRPCError = rerr;

		return ERR_RPC_ERROR;

	}

	return ERR_NONE;

}

/****************************************************************************************

 * 

 * PUBLIC FUNCTION: stopsimulator

 * 

 ***************************************************************************************/

int CCGpssimulator::stopsimulator( int *rv )

{

	struct rpc_err rerr;

	int aArgs = 0;

	// check the rv pointer

	if( rv == NULL ) {

		return ERR_INVALID_RV_POINTER;

	}

	// check that we have a connection

	if( cl == NULL ) {

		return ERR_STUB_NOT_CONNECTED;

	}

	// do the call

	*rv = *stopsimulator_1( &aArgs, cl );

	// check for rpc errors and return the result

	clnt_geterr( cl, &rerr );

	if( rerr.re_status != RPC_SUCCESS ) {

		iLastRPCError = rerr;

		return ERR_RPC_ERROR;

	}

	return ERR_NONE;

}

/****************************************************************************************

 * 

 * PUBLIC FUNCTION: setfielddefault

 * 

 ***************************************************************************************/

int CCGpssimulator::setfielddefault( TField aArgs, int *rv )

{

	struct rpc_err rerr;

	// check the rv pointer

	if( rv == NULL ) {

		return ERR_INVALID_RV_POINTER;

	}

	// check that we have a connection

	if( cl == NULL ) {

		return ERR_STUB_NOT_CONNECTED;

	}

	// do the call

	*rv = *setfielddefault_1( &aArgs, cl );

	// check for rpc errors and return the result

	clnt_geterr( cl, &rerr );

	if( rerr.re_status != RPC_SUCCESS ) {

		iLastRPCError = rerr;

		return ERR_RPC_ERROR;

	}

	return ERR_NONE;

}

/****************************************************************************************

 * 

 * PUBLIC FUNCTION: setsatellitedefault

 * 

 ***************************************************************************************/

int CCGpssimulator::setsatellitedefault( TSatellite aArgs, int *rv )

{

	struct rpc_err rerr;

	// check the rv pointer

	if( rv == NULL ) {

		return ERR_INVALID_RV_POINTER;

	}

	// check that we have a connection

	if( cl == NULL ) {

		return ERR_STUB_NOT_CONNECTED;

	}

	// do the call

	*rv = *setsatellitedefault_1( &aArgs, cl );

	// check for rpc errors and return the result

	clnt_geterr( cl, &rerr );

	if( rerr.re_status != RPC_SUCCESS ) {

		iLastRPCError = rerr;

		return ERR_RPC_ERROR;

	}

	return ERR_NONE;

}

/****************************************************************************************

 * 

 * PUBLIC FUNCTION: positionset

 * 

 ***************************************************************************************/

int CCGpssimulator::positionset( TPositionInfo aArgs, int *rv )

{

	struct rpc_err rerr;

	// check the rv pointer

	if( rv == NULL ) {

		return ERR_INVALID_RV_POINTER;

	}

	// check that we have a connection

	if( cl == NULL ) {

		return ERR_STUB_NOT_CONNECTED;

	}

	// do the call

	*rv = *positionset_1( &aArgs, cl );

	// check for rpc errors and return the result

	clnt_geterr( cl, &rerr );

	if( rerr.re_status != RPC_SUCCESS ) {

		iLastRPCError = rerr;

		return ERR_RPC_ERROR;

	}

	return ERR_NONE;

}

/****************************************************************************************

 * 

 * PUBLIC FUNCTION: courseset

 * 

 ***************************************************************************************/

int CCGpssimulator::courseset( TCourse aArgs, int *rv )

{

	struct rpc_err rerr;

	// check the rv pointer

	if( rv == NULL ) {

		return ERR_INVALID_RV_POINTER;

	}

	// check that we have a connection

	if( cl == NULL ) {

		return ERR_STUB_NOT_CONNECTED;

	}

	// do the call

	*rv = *courseset_1( &aArgs, cl );

	// check for rpc errors and return the result

	clnt_geterr( cl, &rerr );

	if( rerr.re_status != RPC_SUCCESS ) {

		iLastRPCError = rerr;

		return ERR_RPC_ERROR;

	}

	return ERR_NONE;

}

/****************************************************************************************

 * 

 * PUBLIC FUNCTION: accuracyset

 * 

 ***************************************************************************************/

int CCGpssimulator::accuracyset( TAccuracy aArgs, int *rv )

{

	struct rpc_err rerr;

	// check the rv pointer

	if( rv == NULL ) {

		return ERR_INVALID_RV_POINTER;

	}

	// check that we have a connection

	if( cl == NULL ) {

		return ERR_STUB_NOT_CONNECTED;

	}

	// do the call

	*rv = *accuracyset_1( &aArgs, cl );

	// check for rpc errors and return the result

	clnt_geterr( cl, &rerr );

	if( rerr.re_status != RPC_SUCCESS ) {

		iLastRPCError = rerr;

		return ERR_RPC_ERROR;

	}

	return ERR_NONE;

}

/****************************************************************************************

 * 

 * PUBLIC FUNCTION: satelliteset

 * 

 ***************************************************************************************/

int CCGpssimulator::satelliteset( TSatellite aArgs, int *rv )

{

	struct rpc_err rerr;

	// check the rv pointer

	if( rv == NULL ) {

		return ERR_INVALID_RV_POINTER;

	}

	// check that we have a connection

	if( cl == NULL ) {

		return ERR_STUB_NOT_CONNECTED;

	}

	// do the call

	*rv = *satelliteset_1( &aArgs, cl );

	// check for rpc errors and return the result

	clnt_geterr( cl, &rerr );

	if( rerr.re_status != RPC_SUCCESS ) {

		iLastRPCError = rerr;

		return ERR_RPC_ERROR;

	}

	return ERR_NONE;

}

/****************************************************************************************

 * 

 * PUBLIC FUNCTION: batchappendsentence