/*

 * 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;

 }