/*

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

*

*/

//#include<stdio.h>  

#include "test-utils.h"

#include<string.h> 

#include<ctype.h>

#include<unistd.h>  // sleep function is defined in this header file 

#define TEST_BUS_NAME_TEMP "Test.Method.Call1"

dbus_bool_t message_is_error;

void called_file_writecontact(DBusMessage* msg,DBusConnection* connection)

	{

	FILE *fp;  

	char* str;

	dbus_int32_t cnt;

	DBusMessage* reply;

	DBusMessageIter iter;

	DBusMessageIter sub_iter;

	dbus_message_iter_init(msg, &iter);   

	fp = fopen("c:\\data.txt","a+");

	do{

		switch(dbus_message_iter_get_arg_type(&iter))

		{

		case DBUS_TYPE_STRUCT: 

			dbus_message_iter_recurse(&iter, &sub_iter);

			do{

					switch(dbus_message_iter_get_arg_type(&sub_iter))

					{

					case DBUS_TYPE_INT32:

						dbus_message_iter_get_basic(&sub_iter, &cnt);

						fwrite(&cnt, sizeof(cnt),1,fp);

						break;

					case DBUS_TYPE_STRING:

						dbus_message_iter_get_basic(&sub_iter, &str);

						fwrite(str, strlen(str),1,fp);

					} 

					fwrite("\n", strlen("\n"),1,fp);

			}while(dbus_message_iter_next(&sub_iter));

			break;  

		default: 

		fprintf(stdout,"no input"); 

		}

	}while(dbus_message_iter_next(&iter));

	reply = dbus_message_new_method_return(msg);

	dbus_message_append_args(reply, DBUS_TYPE_INT32, &cnt, DBUS_TYPE_INVALID);

	dbus_connection_send(connection, reply, NULL);

	dbus_connection_flush(connection); 

	}

void called_dbus_connection_borrow_message0(DBusMessage* msg,DBusConnection* connection)

	{

		DBusMessage* reply;	

		dbus_int32_t return_value = 9090;

		reply = dbus_message_new_method_return(msg);

		dbus_message_append_args(reply, DBUS_TYPE_INT32, &return_value, DBUS_TYPE_INVALID);

		dbus_connection_send(connection, reply, NULL); 

		dbus_connection_flush(connection); 

	}

void called_dbus_connection_pop_message0(DBusMessage* msg,DBusConnection* connection)

	{

	DBusMessage* reply;	

	dbus_int32_t return_value = 9090;

	reply = dbus_message_new_method_return(msg);

	dbus_message_append_args(reply, DBUS_TYPE_INT32, &return_value, DBUS_TYPE_INVALID);

	dbus_connection_send(connection, reply, NULL);

	dbus_connection_flush(connection);

	}

void called_dbus_connection_steal_borrowed_message0(DBusMessage* msg,DBusConnection* connection)

	{

	DBusMessage* reply;	

	dbus_int32_t return_value = 9090;

	reply = dbus_message_new_method_return(msg);

	dbus_message_append_args(reply, DBUS_TYPE_INT32, &return_value, DBUS_TYPE_INVALID);

	dbus_connection_send(connection, reply, NULL);

	dbus_connection_flush(connection);

	}

void called_dbus_connection_return_message0(DBusMessage* msg,DBusConnection* connection)

	{

	DBusMessage* reply;	

	reply = dbus_message_new_method_return(msg);

	dbus_connection_send(connection, reply, NULL);

	dbus_connection_flush(connection);

	}

void called_dbus_message_new_error_printf0(DBusMessage* msg,DBusConnection* connection)

	{

		char err_succes[]={"ERROR IS SAME"};

		char err_failed[]= {"MISMATCH IN ERROR"};//'M','i','s','m','a','t','c','h',' ','i','n',' ' ,'e','r','r','o','r'

		const char* errorname;

		FILE *fp;

		DBusMessage* err_msg;

		const char* error_name; 

		const char* error_message;

		dbus_int32_t return_value =9090;

		errorname = "dbus.test.error1";

		/* change the error name so that err_failed is printed

		 * for eg: errorname = "dbus.test.error1"

		 * 

		      */

		error_name = "dbus.test.error";  

		error_message = "dbus.message";

		fp = fopen("c:\\method1newerror.txt","w");

		err_msg = dbus_message_new_error(msg,error_name,error_message);  

		message_is_error=dbus_message_is_error(err_msg ,errorname);

		if(message_is_error)

			{

				fwrite(err_succes,1,sizeof(err_succes),fp); 

				fclose(fp);

			}

		else 

			{ 

			fwrite(err_failed,1,sizeof(err_failed),fp);  

			fclose(fp);

			}

		dbus_connection_send(connection, err_msg, NULL); 

		dbus_connection_flush(connection); 

	}

void called_dbus_message_get_no_reply0(DBusMessage* msg,DBusConnection* connection)

	{

		dbus_bool_t nomsg = FALSE;

		char err_succes[]={"Set reply is set/reply not required"};

		char err_fail[]={"Set reply is not been set/reply may be sent"};

		dbus_int32_t return_value = 9090;

		FILE *fp; 

		fp = fopen("c:\\msggetnorply.txt","w"); 

		nomsg = dbus_message_get_no_reply(msg) ;

		if(nomsg)

			{

			fwrite(err_succes,1,sizeof(err_succes),fp); 

			fclose(fp);

			}

		else  

			{

				fwrite(err_fail,1,sizeof(err_fail),fp);  

				fclose(fp);

			}

		dbus_connection_flush(connection); 

	}

int main()

{

	DBusError error;

	DBusError error1;

	DBusConnection* connection;

	DBusMessage* msg;

	DBusObjectPathVTable vtable;

	dbus_error_init(&error);

	dbus_error_init(&error1);

	fprintf(stdout, "Starting Method");

	connection = dbus_bus_get(DBUS_BUS_SESSION, &error);

	if(dbus_error_is_set(&error))

	{

		fprintf(stdout, "Error Occured :: %s", error.name);

		return 1;

	}

	if(dbus_connection_register_object_path (connection, "/Test/Method/Object", &vtable, NULL))

	{

		fprintf(stdout, "Object Path registered.");

	}

	else

	{

		fprintf(stdout, "Object Path not able to register.");

		return 1;

	}

	if(dbus_bus_request_name (connection, TEST_BUS_NAME_TEMP, DBUS_NAME_FLAG_ALLOW_REPLACEMENT, &error1) == -1)

	{

		fprintf(stdout, "Not able to request name.");

	}

	else

	{

		fprintf(stdout, "Name Request Successful");

	}

	while(TRUE)

	{	

		dbus_connection_read_write(connection, 0);

		msg = dbus_connection_pop_message(connection);

		if(msg == NULL)

		{

			sleep(1);

			continue;

		}

		fprintf(stdout, "Message Detected");

		if(DBUS_MESSAGE_TYPE_SIGNAL == dbus_message_get_type(msg))

		{

			fprintf(stdout, "Message is Signal.");

		}

		if(DBUS_MESSAGE_TYPE_METHOD_CALL == dbus_message_get_type(msg))

		{

			fprintf(stdout, "Message is Method call.");

		}

		if(dbus_message_is_method_call(msg, "test.Method.Call", "file_writecontact"))

			{

			called_file_writecontact(msg, connection);

			break;

			}

		if(dbus_message_is_method_call(msg, "test.Method.Call", "dbus_connection_borrow_message0"))

			{

			called_dbus_connection_borrow_message0(msg, connection);

			}

		if(dbus_message_is_method_call(msg, "test.Method.Call", "dbus_connection_pop_message0"))

			{

			called_dbus_connection_pop_message0(msg, connection);

			}

		if(dbus_message_is_method_call(msg, "test.Method.Call", "dbus_connection_steal_borrowed_message0"))

			{

			called_dbus_connection_steal_borrowed_message0(msg, connection);

			}

		if(dbus_message_is_method_call(msg, "test.Method.Call", "dbus_connection_return_message0"))

			{

			called_dbus_connection_return_message0(msg, connection);

			}

		if(dbus_message_is_method_call(msg, "test.Method.Call", "dbus_message_new_error_printf0"))

			{

				called_dbus_message_new_error_printf0(msg, connection);

			}

		if(dbus_message_is_method_call(msg, "test.Method.Call", "dbus_message_get_no_reply0"))

			{

			called_dbus_message_get_no_reply0(msg, connection);

			break;

			} 

		dbus_message_unref(msg);    

	}

	dbus_connection_unref(connection); 

	return 0;

}