/*
 * Copyright 2020 Samsung Electronics Co., Ltd
 *
 * Licensed under the Flora License, Version 1.1 (the License);
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://floralicense.org/license/
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an AS IS BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <stdlib.h>

#include "service_common.h"
#include "service_ipc_dbus_dispatcher.h"
#include "service_main.h"

/*
* Dbus Client-Daemon Server
*/
int CServiceIpcDbusDispatcher::on_hello(DBusConnection* conn, DBusMessage* msg)
{
	MAS_LOGD("[DEBUG] MAS HELLO");

	DBusMessage* reply;
	reply = dbus_message_new_method_return(msg);

	if (NULL != reply) {
		if (!dbus_connection_send(conn, reply, NULL)) {
			MAS_LOGE("[OUT ERROR] Out Of Memory!");
		}

		dbus_connection_flush(conn);
		dbus_message_unref(reply);
	} else {
		MAS_LOGE("[OUT ERROR] Fail to create reply message!!");
	}

	return 0;
}

int CServiceIpcDbusDispatcher::on_initialize(DBusConnection* conn, DBusMessage* msg)
{
	if (nullptr == mIpcObserver) {
		MAS_LOGE("mIpcObserver variable is NULL");
		return -1;
	}

	DBusError err;
	dbus_error_init(&err);

	pid_t pid = -1;
	int ret = 0;

	if (FALSE == dbus_message_get_args(msg, &err,
		DBUS_TYPE_INT32, &pid,
		DBUS_TYPE_INVALID)) {
		MAS_LOGE("[ERROR] Failed retrieving arguments");
	}


	MAS_LOGD("[DEBUG] MAS INITIALIZE");

	if (dbus_error_is_set(&err)) {
		MAS_LOGE("[IN ERROR] mas initialize : get arguments error (%s)", err.message);
		dbus_error_free(&err);
		ret = -1; //MAS_ERROR_OPERATION_FAILED;
	} else {
		MAS_LOGD("[IN] mas initialize : pid(%d)", pid);
		const char *sender = dbus_message_get_sender(msg);
		ret = mIpcObserver->on_initialize(pid, (sender ? sender : ""));
	}

	DBusMessage* reply;
	reply = dbus_message_new_method_return(msg);

 	MAS_LOGI("[OUT] mas initialize : result(%d)", ret);
	if (NULL != reply) {
		dbus_message_append_args(reply,
			DBUS_TYPE_INT32, &ret,
			DBUS_TYPE_INVALID);

		if (0 == ret) {
			MAS_LOGD("[OUT] mas initialize : result(%d)", ret);
		} else {
			MAS_LOGE("[OUT ERROR] mas initialize : result(%d)", ret);
		}

		if (!dbus_connection_send(conn, reply, NULL)) {
			MAS_LOGE("[OUT ERROR] mas initialize : Out Of Memory!");
		}

		dbus_connection_flush(conn);
		dbus_message_unref(reply);
	} else {
		MAS_LOGE("[OUT ERROR] mas initialize : Fail to create reply message!!");
	}

	return ret;
}

int CServiceIpcDbusDispatcher::on_deinitialize(DBusConnection* conn, DBusMessage* msg)
{
	if (nullptr == mIpcObserver) {
		MAS_LOGE("mIpcObserver variable is NULL");
		return -1;
	}

	DBusError err;
	dbus_error_init(&err);

	pid_t pid = -1;
	int ret = 0;

	if (FALSE == dbus_message_get_args(msg, &err,
		DBUS_TYPE_INT32, &pid,
		DBUS_TYPE_INVALID)) {
		MAS_LOGE("[ERROR] Failed retrieving arguments");
	}

	MAS_LOGD("[DEBUG] MAS DEINITIALIZE");

	if (dbus_error_is_set(&err)) {
		MAS_LOGE("[IN ERROR] mas deinitialize : get arguments error (%s)", err.message);
		dbus_error_free(&err);
		ret = -1; //MAS_ERROR_OPERATION_FAILED;
	} else {
		MAS_LOGD("[IN] mas deinitialize : pid(%d)", pid);
		const char *sender = dbus_message_get_sender(msg);
		ret = mIpcObserver->on_deinitialize(pid, (sender ? sender : ""));
	}

	DBusMessage* reply;
	reply = dbus_message_new_method_return(msg);

	MAS_LOGI("[OUT] mas deinitialize : result(%d)", ret);
	if (NULL != reply) {
		dbus_message_append_args(reply,
			DBUS_TYPE_INT32, &ret,
			DBUS_TYPE_INVALID);

		if (0 == ret) {
			MAS_LOGD("[OUT] mas deinitialize : result(%d)", ret);
		} else {
			MAS_LOGE("[OUT ERROR] mas deinitialize : result(%d)", ret);
		}

		if (!dbus_connection_send(conn, reply, NULL)) {
			MAS_LOGE("[OUT ERROR] mas deinitialize : Out Of Memory!");
		}

		dbus_connection_flush(conn);
		dbus_message_unref(reply);
	} else {
		MAS_LOGE("[OUT ERROR] mas deinitialize : Fail to create reply message!!");
	}

	return 0;
}

int CServiceIpcDbusDispatcher::on_get_audio_format(DBusConnection* conn, DBusMessage* msg)
{
	if (nullptr == mIpcObserver) {
		MAS_LOGE("mIpcObserver variable is NULL");
		return -1;
	}

	DBusError err;
	dbus_error_init(&err);

	pid_t pid = -1;
	int rate, channel, audio_type;
	int ret;

	if (FALSE == dbus_message_get_args(msg, &err,
		DBUS_TYPE_INT32, &pid,
		DBUS_TYPE_INVALID)) {
		MAS_LOGE("[ERROR] Failed retrieving arguments");
	}

	MAS_LOGD("[DEBUG] MAS GET AUDIO FORMAT");

	if (dbus_error_is_set(&err)) {
		MAS_LOGE("[IN ERROR] mas get audio format : Get arguments error (%s)", err.message);
		dbus_error_free(&err);
		ret = -1; //MAS_ERROR_OPERATION_FAILED;
	} else {
		MAS_LOGD("[IN] mas get audio format");
		const char *sender = dbus_message_get_sender(msg);
		ret = mIpcObserver->on_get_audio_format(pid, rate, channel, audio_type, (sender ? sender : ""));
	}

	DBusMessage* reply;
	reply = dbus_message_new_method_return(msg);

	if (NULL != reply) {
		/* Append result and voice */
		dbus_message_append_args(reply,
			DBUS_TYPE_INT32, &ret,
			DBUS_TYPE_INT32, &rate,
			DBUS_TYPE_INT32, &channel,
			DBUS_TYPE_INT32, &audio_type,
			DBUS_TYPE_INVALID);
		if (0 == ret) {
			MAS_LOGI("[OUT] mas get audio format : rate(%d), channel(%d), audio_type(%d)", rate, channel, audio_type);
		} else {
			MAS_LOGE("[OUT ERROR] mas get audio format : result(%d)", ret);
		}

		if (!dbus_connection_send(conn, reply, NULL)) {
			MAS_LOGE("[OUT ERROR] mas get audio format : Out Of Memory!");
		}

		dbus_connection_flush(conn);
		dbus_message_unref(reply);
	} else {
		MAS_LOGE("[OUT ERROR] tts default voice : Fail to create reply message!!");
	}

	return ret;
}

int CServiceIpcDbusDispatcher::on_get_audio_source_type(DBusConnection* conn, DBusMessage* msg)
{
	if (nullptr == mIpcObserver) {
		MAS_LOGE("mIpcObserver variable is NULL");
		return -1;
	}

	DBusError err;
	dbus_error_init(&err);

	pid_t pid = -1;
	std::string type;
	int ret;

	if (FALSE == dbus_message_get_args(msg, &err,
		DBUS_TYPE_INT32, &pid,
		DBUS_TYPE_INVALID)) {
		MAS_LOGE("[ERROR] Failed retrieving arguments");
	}

	MAS_LOGD("[DEBUG] MAS GET AUDIO SOURCE TYPE");

	if (dbus_error_is_set(&err)) {
		MAS_LOGE("[IN ERROR] mas get audio source type : Get arguments error (%s)", err.message);
		dbus_error_free(&err);
		ret = -1; //MAS_ERROR_OPERATION_FAILED;
	} else {
		MAS_LOGD("[IN] mas get audio source type");
		const char *sender = dbus_message_get_sender(msg);
		ret = mIpcObserver->on_get_audio_source_type(pid, type, (sender ? sender : ""));
	}

	DBusMessage* reply;
	reply = dbus_message_new_method_return(msg);

	char* temp_type = NULL;

	if (-1 == ret)
		temp_type = strdup("#NULL");
	else
		temp_type = strdup(type.c_str());

	if (NULL != reply) {
		/* Append result and voice */
		dbus_message_append_args(reply,
			DBUS_TYPE_INT32, &ret,
			DBUS_TYPE_STRING, &temp_type,
			DBUS_TYPE_INVALID);
		if (0 == ret) {
			MAS_LOGI("[OUT] mas get audio source type : type(%s)", temp_type);
		} else {
			MAS_LOGE("[OUT ERROR] mas get audio source type : result(%d)", ret);
		}

		if (!dbus_connection_send(conn, reply, NULL)) {
			MAS_LOGE("[OUT ERROR] mas get audio source type : Out Of Memory!");
		}

		dbus_connection_flush(conn);
		dbus_message_unref(reply);
	} else {
		MAS_LOGE("[OUT ERROR] mas get audio source type : Fail to create reply message!!");
	}

	if (temp_type)
		free(temp_type);

	return ret;
}

int CServiceIpcDbusDispatcher::on_send_asr_result(DBusConnection* conn, DBusMessage* msg)
{
	if (nullptr == mIpcObserver) {
		MAS_LOGE("mIpcObserver variable is NULL");
		return -1;
	}

	DBusError err;
	dbus_error_init(&err);

	pid_t pid, event;
	char *asr_result;
	int ret = 0;

	if (FALSE == dbus_message_get_args(msg, &err,
		DBUS_TYPE_INT32, &pid,
		DBUS_TYPE_INT32, &event,
		DBUS_TYPE_STRING, &asr_result,
		DBUS_TYPE_INVALID)) {
		MAS_LOGE("[ERROR] Failed retrieving arguments");
	}

	MAS_LOGD("[DEBUG] MAS SEND ASR RESULT");

	if (dbus_error_is_set(&err)) {
		MAS_LOGE("[IN ERROR] mas send asr result : Get arguments error (%s)", err.message);
		dbus_error_free(&err);
		ret = -1; //MAS_ERROR_OPERATION_FAILED;
	} else {
		MAS_LOGI("[IN] mas send asr result : pid(%d), event(%d), asr_result(%s)", pid, event, asr_result);
		const char *sender = dbus_message_get_sender(msg);
		ret = mIpcObserver->on_send_asr_result(pid, event,
			asr_result ? std::string{asr_result} : std::string{},
			(sender ? sender : ""));
	}

	DBusMessage* reply;
	reply = dbus_message_new_method_return(msg);

	if (NULL != reply) {
		dbus_message_append_args(reply,
			DBUS_TYPE_INT32, &ret,
			DBUS_TYPE_INVALID);

		if (0 == ret) {
			MAS_LOGD("[OUT] mas send asr result : result(%d)", ret);
		} else {
			MAS_LOGE("[OUT ERROR] mas send asr result : result(%d)", ret);
		}

		if (!dbus_connection_send(conn, reply, NULL)) {
			MAS_LOGE("[OUT ERROR] mas send asr result : Out Of Memory!");
		}

		dbus_connection_flush(conn);
		dbus_message_unref(reply);
	} else {
		MAS_LOGE("[OUT ERROR] mas send asr result : Fail to create reply message!!");
	}

	MAS_LOGD("<<<<<");
	MAS_LOGD("  ");

	return ret;
}

int CServiceIpcDbusDispatcher::on_send_result(DBusConnection* conn, DBusMessage* msg)
{
	if (nullptr == mIpcObserver) {
		MAS_LOGE("mIpcObserver variable is NULL");
		return -1;
	}

	DBusError err;
	dbus_error_init(&err);

	pid_t pid;
	char* display_text;
	char* utterance_text;
	char* result_json;
	int ret = 0;

	if (FALSE == dbus_message_get_args(msg, &err,
		DBUS_TYPE_INT32, &pid,
		DBUS_TYPE_STRING, &display_text,
		DBUS_TYPE_STRING, &utterance_text,
		DBUS_TYPE_STRING, &result_json,
		DBUS_TYPE_INVALID)) {
		MAS_LOGE("[ERROR] Failed retrieving arguments");
	}

	MAS_LOGD("[DEBUG] MAS SEND RESULT");

	if (dbus_error_is_set(&err)) {
		MAS_LOGE("[IN ERROR] mas send result : Get arguments error (%s)", err.message);
		dbus_error_free(&err);
		ret = -1; //MAS_ERROR_OPERATION_FAILED;
	} else {
		MAS_LOGI("[IN] mas send result : pid(%d), display_text(%s), utterance_text(%s), result_json(%s)", pid, display_text, utterance_text, result_json);
		const char *sender = dbus_message_get_sender(msg);
		ret = mIpcObserver->on_send_result(pid,
			display_text ? std::string{display_text} : std::string{},
			utterance_text ? std::string{utterance_text} : std::string{},
			result_json ? std::string{result_json} : std::string{},
			(sender ? sender : ""));
	}

	DBusMessage* reply;
	reply = dbus_message_new_method_return(msg);

	if (NULL != reply) {
		dbus_message_append_args(reply,
			DBUS_TYPE_INT32, &ret,
			DBUS_TYPE_INVALID);

		if (0 == ret) {
			MAS_LOGD("[OUT] mas send result : result(%d)", ret);
		} else {
			MAS_LOGE("[OUT ERROR] mas send result : result(%d)", ret);
		}

		if (!dbus_connection_send(conn, reply, NULL)) {
			MAS_LOGE("[OUT ERROR] mas send result : Out Of Memory!");
		}

		dbus_connection_flush(conn);
		dbus_message_unref(reply);
	} else {
		MAS_LOGE("[OUT ERROR] mas send result : Fail to create reply message!!");
	}

	MAS_LOGD("<<<<<");
	MAS_LOGD("  ");

	return ret;
}

int CServiceIpcDbusDispatcher::on_send_recognition_result(DBusConnection* conn, DBusMessage* msg)
{
	if (nullptr == mIpcObserver) {
		MAS_LOGE("mIpcObserver variable is NULL");
		return -1;
	}

	DBusError err;
	dbus_error_init(&err);

	pid_t pid;
	int result;
	int ret = 0;

	if (FALSE == dbus_message_get_args(msg, &err,
		DBUS_TYPE_INT32, &pid,
		DBUS_TYPE_INT32, &result,
		DBUS_TYPE_INVALID)) {
		MAS_LOGE("[ERROR] Failed retrieving arguments");
	}

	MAS_LOGD("[DEBUG] MAS SEND RECOGNITION RESULT");

	if (dbus_error_is_set(&err)) {
		MAS_LOGE("[IN ERROR] mas send recognition result : Get arguments error (%s)", err.message);
		dbus_error_free(&err);
		ret = -1; //MAS_ERROR_OPERATION_FAILED;
	} else {
		MAS_LOGI("[IN] mas send recognition result : pid(%d), result(%d)", pid, result);
		const char *sender = dbus_message_get_sender(msg);
		ret = mIpcObserver->on_send_recognition_result(pid, result, (sender ? sender : ""));
	}

	MAS_LOGD("<<<<<");
	MAS_LOGD("  ");

	return ret;
}

int CServiceIpcDbusDispatcher::on_start_streaming_audio_data(DBusConnection* conn, DBusMessage* msg)
{
	if (nullptr == mIpcObserver) {
		MAS_LOGE("mIpcObserver variable is NULL");
		return -1;
	}

	DBusError err;
	dbus_error_init(&err);

	pid_t pid;
	int type;
	int ret = 0;

	if (FALSE == dbus_message_get_args(msg, &err,
		DBUS_TYPE_INT32, &pid,
		DBUS_TYPE_INT32, &type,
		DBUS_TYPE_INVALID)) {
		MAS_LOGE("[ERROR] Failed retrieving arguments");
	}

	MAS_LOGD("[DEBUG] MAS SEND START STREAMING");

	if (dbus_error_is_set(&err)) {
		MAS_LOGE("[IN ERROR] mas send start streaming : Get arguments error (%s)", err.message);
		dbus_error_free(&err);
		ret = -1; //MAS_ERROR_OPERATION_FAILED;
	} else {
		MAS_LOGI("[IN] mas send start streaming : pid(%d), type(%d)", pid, type);
		const char *sender = dbus_message_get_sender(msg);
		ret = mIpcObserver->on_start_streaming_audio_data(pid, type, (sender ? sender : ""));
	}

	MAS_LOGD("<<<<<");
	MAS_LOGD("  ");

	return ret;
}

int CServiceIpcDbusDispatcher::on_stop_streaming_audio_data(DBusConnection* conn, DBusMessage* msg)
{
	if (nullptr == mIpcObserver) {
		MAS_LOGE("mIpcObserver variable is NULL");
		return -1;
	}

	DBusError err;
	dbus_error_init(&err);

	pid_t pid;
	int type;
	int ret = 0;

	if (FALSE == dbus_message_get_args(msg, &err,
		DBUS_TYPE_INT32, &pid,
		DBUS_TYPE_INT32, &type,
		DBUS_TYPE_INVALID)) {
		MAS_LOGE("[ERROR] Failed retrieving arguments");
	}

	MAS_LOGD("[DEBUG] MAS SEND STOP STREAMING");

	if (dbus_error_is_set(&err)) {
		MAS_LOGE("[IN ERROR] mas stop streaming : Get arguments error (%s)", err.message);
		dbus_error_free(&err);
		ret = -1; //MAS_ERROR_OPERATION_FAILED;
	} else {
		MAS_LOGI("[IN] mas stop streaming : pid(%d), type(%d)", pid, type);
		const char *sender = dbus_message_get_sender(msg);
		ret = mIpcObserver->on_stop_streaming_audio_data(pid, type, (sender ? sender : ""));
	}

	MAS_LOGD("<<<<<");
	MAS_LOGD("  ");

	return ret;
}

int CServiceIpcDbusDispatcher::on_update_voice_feedback_state(DBusConnection* conn, DBusMessage* msg)
{
	if (nullptr == mIpcObserver) {
		MAS_LOGE("mIpcObserver variable is NULL");
		return -1;
	}

	DBusError err;
	dbus_error_init(&err);

	pid_t pid;
	int state;
	int ret = 0;

	if (FALSE == dbus_message_get_args(msg, &err,
		DBUS_TYPE_INT32, &pid,
		DBUS_TYPE_INT32, &state,
		DBUS_TYPE_INVALID)) {
		MAS_LOGE("[ERROR] Failed retrieving arguments");
	}

	MAS_LOGD("[DEBUG] MAS SEND UPDATE VOICE FEEDBACK");

	if (dbus_error_is_set(&err)) {
		MAS_LOGE("[IN ERROR] mas update voice feedback : Get arguments error (%s)", err.message);
		dbus_error_free(&err);
		ret = -1; //MAS_ERROR_OPERATION_FAILED;
	} else {
		MAS_LOGI("[IN] mas update voice feedback : pid(%d), state(%d)", pid, state);
		const char *sender = dbus_message_get_sender(msg);
		ret = mIpcObserver->on_update_voice_feedback_state(pid, state, (sender ? sender : ""));
	}

	MAS_LOGD("<<<<<");
	MAS_LOGD("  ");

	return ret;
}

int CServiceIpcDbusDispatcher::on_send_assistant_specific_command(DBusConnection* conn, DBusMessage* msg)
{
	if (nullptr == mIpcObserver) {
		MAS_LOGE("mIpcObserver variable is NULL");
		return -1;
	}

	DBusError err;
	dbus_error_init(&err);

	pid_t pid;
	int ret = 0;
	char* command;

	if (FALSE == dbus_message_get_args(msg, &err,
		DBUS_TYPE_INT32, &pid,
		DBUS_TYPE_STRING, &command,
		DBUS_TYPE_INVALID)) {
		MAS_LOGE("[ERROR] Failed retrieving arguments");
	}

	MAS_LOGD("[DEBUG] MAS SEND ASSISTANT SPECIFIC COMMAND");

	if (dbus_error_is_set(&err)) {
		MAS_LOGE("[IN ERROR] mas send assistant specific command : Get arguments error (%s)", err.message);
		dbus_error_free(&err);
		ret = -1; //MAS_ERROR_OPERATION_FAILED;
	} else {
		MAS_LOGI("[IN] mas send assistant specific command : pid(%d), command(%s)", pid, command);
		const char *sender = dbus_message_get_sender(msg);
		ret = mIpcObserver->on_send_assistant_specific_command(pid,
			command ? std::string{command} : std::string{},
			(sender ? sender : ""));
	}

	MAS_LOGD("<<<<<");
	MAS_LOGD("  ");

	return ret;
}

int CServiceIpcDbusDispatcher::on_set_background_volume(DBusConnection* conn, DBusMessage* msg)
{
	if (nullptr == mIpcObserver) {
		MAS_LOGE("mIpcObserver variable is NULL");
		return -1;
	}

	DBusError err;
	dbus_error_init(&err);

	pid_t pid;
	int ret = 0;
	double ratio;

	if (FALSE == dbus_message_get_args(msg, &err,
		DBUS_TYPE_INT32, &pid,
		DBUS_TYPE_DOUBLE, &ratio,
		DBUS_TYPE_INVALID)) {
		MAS_LOGE("[ERROR] Failed retrieving arguments");
	}

	MAS_LOGD("[DEBUG] MAS SET BACKGROUND VOLUME");

	if (dbus_error_is_set(&err)) {
		MAS_LOGE("[IN ERROR] mas set background volume : Get arguments error (%s)", err.message);
		dbus_error_free(&err);
		ret = -1; //MAS_ERROR_OPERATION_FAILED;
	} else {
		MAS_LOGI("[IN] mas set background volume : pid(%d), ratio(%f)", pid, ratio);
		const char *sender = dbus_message_get_sender(msg);
		ret = mIpcObserver->on_set_background_volume(pid, ratio, (sender ? sender : ""));
	}

	MAS_LOGD("<<<<<");
	MAS_LOGD("  ");

	return ret;
}

int CServiceIpcDbusDispatcher::on_set_preprocessing_allow_mode(DBusConnection* conn, DBusMessage* msg)
{
	if (nullptr == mIpcObserver) {
		MAS_LOGE("mIpcObserver variable is NULL");
		return -1;
	}

	DBusError err;
	dbus_error_init(&err);

	pid_t pid;
	int ret = 0;
	int mode;
	char* app_id;

	if (FALSE == dbus_message_get_args(msg, &err,
		DBUS_TYPE_INT32, &pid,
		DBUS_TYPE_INT32, &mode,
		DBUS_TYPE_STRING, &app_id,
		DBUS_TYPE_INVALID)) {
		MAS_LOGE("[ERROR] Failed retrieving arguments");
	}

	MAS_LOGD("[DEBUG] MAS SET PREPROCESSING ALLOW MODE");

	if (dbus_error_is_set(&err)) {
		MAS_LOGE("[IN ERROR] mas set preprocessing allow mode : Get arguments error (%s)", err.message);
		dbus_error_free(&err);
		ret = -1; //MAS_ERROR_OPERATION_FAILED;
	} else {
		MAS_LOGI("[IN] mas set preprocessing allow mode : pid(%d), mode(%d), app_id(%s)", pid, mode, app_id);
		const char *sender = dbus_message_get_sender(msg);
		ret = mIpcObserver->on_set_preprocessing_allow_mode(pid,
			static_cast<ma_preprocessing_allow_mode_e>(mode),
			app_id ? std::string{app_id} : std::string{},
			(sender ? sender : ""));
	}

	MAS_LOGD("<<<<<");
	MAS_LOGD("  ");

	return ret;
}

int CServiceIpcDbusDispatcher::on_send_preprocessing_result(DBusConnection* conn, DBusMessage* msg)
{
	if (nullptr == mIpcObserver) {
		MAS_LOGE("mIpcObserver variable is NULL");
		return -1;
	}

	DBusError err;
	dbus_error_init(&err);

	pid_t pid;
	int ret = 0;
	int result;

	if (FALSE == dbus_message_get_args(msg, &err,
		DBUS_TYPE_INT32, &pid,
		DBUS_TYPE_INT32, &result,
		DBUS_TYPE_INVALID)) {
		MAS_LOGE("[ERROR] Failed retrieving arguments");
	}

	MAS_LOGD("[DEBUG] MAS SEND PREPROCESSING RESULT");

	if (dbus_error_is_set(&err)) {
		MAS_LOGE("[IN ERROR] mas send preprocessing result : Get arguments error (%s)", err.message);
		dbus_error_free(&err);
		ret = -1; //MAS_ERROR_OPERATION_FAILED;
	} else {
		MAS_LOGI("[IN] mas send preprocessing result : pid(%d), result(%d)", pid, result);
		const char *sender = dbus_message_get_sender(msg);
		ret = mIpcObserver->on_send_preprocessing_result(pid, result, (sender ? sender : ""));
	}

	MAS_LOGD("<<<<<");
	MAS_LOGD("  ");

	return ret;
}

int CServiceIpcDbusDispatcher::on_set_wake_word_audio_require_flag(DBusConnection* conn, DBusMessage* msg)
{
	if (nullptr == mIpcObserver) {
		MAS_LOGE("mIpcObserver variable is NULL");
		return -1;
	}

	DBusError err;
	dbus_error_init(&err);

	pid_t pid;
	int ret = 0;
	int require;

	if (FALSE == dbus_message_get_args(msg, &err,
		DBUS_TYPE_INT32, &pid,
		DBUS_TYPE_INT32, &require,
		DBUS_TYPE_INVALID)) {
		MAS_LOGE("[ERROR] Failed retrieving arguments");
	}

	MAS_LOGD("[DEBUG] MAS SET WAKE WORD AUDIO REQUIRE FLAG");

	if (dbus_error_is_set(&err)) {
		MAS_LOGE("[IN ERROR] mas set wake word audio require flag : Get arguments error (%s)", err.message);
		dbus_error_free(&err);
		ret = -1; //MAS_ERROR_OPERATION_FAILED;
	} else {
		MAS_LOGI("[IN] mas set wake word audio require flag : pid(%d), require(%d)", pid, require);
		const char *sender = dbus_message_get_sender(msg);
		ret = mIpcObserver->on_set_wake_word_audio_require_flag(pid, require, (sender ? sender : ""));
	}

	MAS_LOGD("<<<<<");
	MAS_LOGD("  ");

	return ret;
}

int CServiceIpcDbusDispatcher::on_set_assistant_language(DBusConnection* conn, DBusMessage* msg)
{
	if (nullptr == mIpcObserver) {
		MAS_LOGE("mIpcObserver variable is NULL");
		return -1;
	}

	DBusError err;
	dbus_error_init(&err);

	pid_t pid;
	int ret = 0;
	char* language;

	if (FALSE == dbus_message_get_args(msg, &err,
		DBUS_TYPE_INT32, &pid,
		DBUS_TYPE_STRING, &language,
		DBUS_TYPE_INVALID)) {
		MAS_LOGE("[ERROR] Failed retrieving arguments");
	}

	MAS_LOGD("[DEBUG] MAS SET ASSISTANT LANGUAGE");

	if (dbus_error_is_set(&err)) {
		MAS_LOGE("[IN ERROR] mas set assistant language : Get arguments error (%s)", err.message);
		dbus_error_free(&err);
		ret = -1; //MAS_ERROR_OPERATION_FAILED;
	} else {
		MAS_LOGI("[IN] mas set assistant language : pid(%d), language(%s)", pid, language);
		const char *sender = dbus_message_get_sender(msg);
		ret = mIpcObserver->on_set_assistant_language(pid,
			language ? std::string{language} : std::string{},
			(sender ? sender : ""));
	}

	MAS_LOGD("<<<<<");
	MAS_LOGD("  ");

	return ret;
}

int CServiceIpcDbusDispatcher::on_add_wake_word(DBusConnection* conn, DBusMessage* msg)
{
	if (nullptr == mIpcObserver) {
		MAS_LOGE("mIpcObserver variable is NULL");
		return -1;
	}

	DBusError err;
	dbus_error_init(&err);

	pid_t pid;
	int ret = 0;
	char* wake_word;
	char* language;

	if (FALSE == dbus_message_get_args(msg, &err,
		DBUS_TYPE_INT32, &pid,
		DBUS_TYPE_STRING, &wake_word,
		DBUS_TYPE_STRING, &language,
		DBUS_TYPE_INVALID)) {
		MAS_LOGE("[ERROR] Failed retrieving arguments");
	}

	MAS_LOGD("[DEBUG] MAS ADD WAKE WORD");

	if (dbus_error_is_set(&err)) {
		MAS_LOGE("[IN ERROR] mas add wake word : Get arguments error (%s)", err.message);
		dbus_error_free(&err);
		ret = -1; //MAS_ERROR_OPERATION_FAILED;
	} else {
		MAS_LOGI("[IN] mas add wake word : pid(%d), wake_word(%s) language(%s)", pid, wake_word, language);
		const char *sender = dbus_message_get_sender(msg);
		ret = mIpcObserver->on_add_wake_word(pid,
			wake_word ? std::string{wake_word} : std::string{},
			language ? std::string{language} : std::string{},
			(sender ? sender : ""));
	}

	MAS_LOGD("<<<<<");
	MAS_LOGD("  ");

	return ret;
}

int CServiceIpcDbusDispatcher::on_remove_wake_word(DBusConnection* conn, DBusMessage* msg)
{
	if (nullptr == mIpcObserver) {
		MAS_LOGE("mIpcObserver variable is NULL");
		return -1;
	}

	DBusError err;
	dbus_error_init(&err);

	pid_t pid;
	int ret = 0;
	char* wake_word;
	char* language;

	if (FALSE == dbus_message_get_args(msg, &err,
		DBUS_TYPE_INT32, &pid,
		DBUS_TYPE_STRING, &wake_word,
		DBUS_TYPE_STRING, &language,
		DBUS_TYPE_INVALID)) {
		MAS_LOGE("[ERROR] Failed retrieving arguments");
	}

	MAS_LOGD("[DEBUG] MAS REMOVE WAKE WORD");

	if (dbus_error_is_set(&err)) {
		MAS_LOGE("[IN ERROR] mas remove wake word : Get arguments error (%s)", err.message);
		dbus_error_free(&err);
		ret = -1; //MAS_ERROR_OPERATION_FAILED;
	} else {
		MAS_LOGI("[IN] mas remove wake word : pid(%d), wake_word(%s) language(%s)", pid, wake_word, language);
		const char *sender = dbus_message_get_sender(msg);
		ret = mIpcObserver->on_remove_wake_word(pid,
			wake_word ? std::string{wake_word} : std::string{},
			language ? std::string{language} : std::string{},
			(sender ? sender : ""));
	}

	MAS_LOGD("<<<<<");
	MAS_LOGD("  ");

	return ret;
}

int CServiceIpcDbusDispatcher::on_ui_initialize(DBusConnection* conn, DBusMessage* msg)
{
	if (nullptr == mIpcObserver) {
		MAS_LOGE("mIpcObserver variable is NULL");
		return -1;
	}

	DBusError err;
	dbus_error_init(&err);

	pid_t pid = -1;
	int ret = 0;

	if (FALSE == dbus_message_get_args(msg, &err,
		DBUS_TYPE_INT32, &pid,
		DBUS_TYPE_INVALID)) {
		MAS_LOGE("[ERROR] Failed retrieving arguments");
	}

	MAS_LOGD("[DEBUG] MAS UI INITIALIZE");

	if (dbus_error_is_set(&err)) {
		MAS_LOGE("[IN ERROR] mas ui initialize : get arguments error (%s)", err.message);
		dbus_error_free(&err);
		ret = -1; //MAS_ERROR_OPERATION_FAILED;
	} else {
		MAS_LOGD("[IN] mas ui initialize : pid(%d)", pid);
		ret = mIpcObserver->on_ui_initialize(pid);
	}

	DBusMessage* reply;
	reply = dbus_message_new_method_return(msg);

	MAS_LOGD("[OUT] mas ui initialize : result(%d)", ret);
	if (NULL != reply) {
		dbus_message_append_args(reply,
			DBUS_TYPE_INT32, &ret,
			DBUS_TYPE_INVALID);

		if (0 == ret) {
			MAS_LOGD("[OUT] mas ui initialize : result(%d)", ret);
		} else {
			MAS_LOGE("[OUT ERROR] mas ui initialize : result(%d)", ret);
		}

		if (!dbus_connection_send(conn, reply, NULL)) {
			MAS_LOGE("[OUT ERROR] mas ui initialize : Out Of Memory!");
		}

		dbus_connection_flush(conn);
		dbus_message_unref(reply);
	} else {
		MAS_LOGE("[OUT ERROR] mas ui initialize : Fail to create reply message!!");
	}

	return ret;
}

int CServiceIpcDbusDispatcher::on_ui_deinitialize(DBusConnection* conn, DBusMessage* msg)
{
	if (nullptr == mIpcObserver) {
		MAS_LOGE("mIpcObserver variable is NULL");
		return -1;
	}

	DBusError err;
	dbus_error_init(&err);

	pid_t pid = -1;
	int ret = 0;

	if (FALSE == dbus_message_get_args(msg, &err,
		DBUS_TYPE_INT32, &pid,
		DBUS_TYPE_INVALID)) {
		MAS_LOGE("[ERROR] Failed retrieving arguments");
	}

	MAS_LOGD("[DEBUG] MAS UI DEINITIALIZE");

	if (dbus_error_is_set(&err)) {
		MAS_LOGE("[IN ERROR] mas ui deinitialize : get arguments error (%s)", err.message);
		dbus_error_free(&err);
		ret = -1; //MAS_ERROR_OPERATION_FAILED;
	} else {
		MAS_LOGD("[IN] mas ui deinitialize : pid(%d)", pid);
		ret = mIpcObserver->on_ui_deinitialize(pid);
	}

	DBusMessage* reply;
	reply = dbus_message_new_method_return(msg);

	MAS_LOGD("[OUT] mas ui deinitialize : result(%d)", ret);
	if (NULL != reply) {
		dbus_message_append_args(reply,
			DBUS_TYPE_INT32, &ret,
			DBUS_TYPE_INVALID);

		if (0 == ret) {
			MAS_LOGD("[OUT] mas ui deinitialize : result(%d)", ret);
		} else {
			MAS_LOGE("[OUT ERROR] mas ui deinitialize : result(%d)", ret);
		}

		if (!dbus_connection_send(conn, reply, NULL)) {
			MAS_LOGE("[OUT ERROR] mas ui deinitialize : Out Of Memory!");
		}

		dbus_connection_flush(conn);
		dbus_message_unref(reply);
	} else {
		MAS_LOGE("[OUT ERROR] mas ui deinitialize : Fail to create reply message!!");
	}

	return ret;
}

int CServiceIpcDbusDispatcher::on_ui_change_assistant(DBusConnection* conn, DBusMessage* msg)
{
	if (nullptr == mIpcObserver) {
		MAS_LOGE("mIpcObserver variable is NULL");
		return -1;
	}

	DBusError err;
	dbus_error_init(&err);

	char *app_id;
	int ret = 0;

	if (FALSE == dbus_message_get_args(msg, &err,
		DBUS_TYPE_STRING, &app_id,
		DBUS_TYPE_INVALID)) {
		MAS_LOGE("[ERROR] Failed retrieving arguments");
	}

	MAS_LOGD("[DEBUG] MAS UI CHANGE ASSISTANT : %s", (app_id ? app_id : "NULL"));

	if (dbus_error_is_set(&err)) {
		MAS_LOGE("[IN ERROR] mas ui change assisant : Get arguments error (%s)", err.message);
		dbus_error_free(&err);
		ret = -1; //MAS_ERROR_OPERATION_FAILED;
	} else {
		MAS_LOGD("[IN] mas ui change assisant : app_id(%s)", app_id);
		ret = mIpcObserver->on_ui_change_assistant(
			app_id ? std::string{app_id} : std::string{});
	}

	DBusMessage* reply;
	reply = dbus_message_new_method_return(msg);

	if (NULL != reply) {
		dbus_message_append_args(reply,
			DBUS_TYPE_INT32, &ret,
			DBUS_TYPE_INVALID);

		if (0 == ret) {
			MAS_LOGD("[OUT] mas ui change assisant : result(%d)", ret);
		} else {
			MAS_LOGE("[OUT ERROR] mas ui change assisant : result(%d)", ret);
		}

		if (!dbus_connection_send(conn, reply, NULL)) {
			MAS_LOGE("[OUT ERROR] mas ui change assisant : Out Of Memory!");
		}

		dbus_connection_flush(conn);
		dbus_message_unref(reply);
	} else {
		MAS_LOGE("[OUT ERROR] mas ui change assisant : Fail to create reply message!!");
	}

	MAS_LOGD("<<<<<");
	MAS_LOGD("  ");

	return ret;
}