path: root/src/procedures.c

/*
 * TODO: rename this to dbus_procedures.c
 * procedures, available procedures
 *
 * Copyright (c) 2015 Ultimaker B.V.
 * Author: Olliver Schinagl <o.schinagl@ultimaker.com>
 *
 * SPDX-License-Identifier:	AGPL-3.0+
 */

#include <Eina.h>
#include <Eldbus.h>
#include <stdint.h>

#include "dbus_common.h"
#include "eulogium.h"
#include "print_data.h"
#include "procedures.h"
#include "settings_data.h"
#include "ui_widgets.h"

#define _PROC_FIRMWARE_UPDATE "FIRMWARE_UPDATE"

#define _PROC_PRINT "PRINT"
#define _META_PROGRESS_JOBNAME "jobname"
#define _META_PROGRESS_TIME "time"
#define _META_PROGRESS_TIME_TOTAL "time_total"
#define _META_PROGRESS "progress"

#define _PROC_POST_PRINT "POST_PRINT"
#define _PROC_PRE_PRINT_SETUP "PRE_PRINT_SETUP"
#define _PROC_RUN_PRE_PRINT_SETUP "RUN_PRE_PRINT_SETUP"
#define _PROC_WAIT_FOR_CLEANUP "WAIT_FOR_CLEANUP"

#define _PROC_BED_HEATUP "HEATUP_BED"
#define _PROC_BED_MOVE "MOVE_BED"
#define _PROC_HOTEND_HEATUP_0 "HEATUP_HOTEND_0"
#define _PROC_HOTEND_HEATUP_1 "HEATUP_HOTEND_1"
#define _PROC_HOTEND_ACTIVE_SET "SWITCH_ACTIVE_HOTEND"
#define _PROC_PRINT_SPEED "PRINT_SPEED"
#define _PROC_FAN_SPEED "FAN_SPEED"
#define _PROC_FLOW_RATE "MATERIAL_FLOW"
#define _PROC_RETRACTION_LENGTH "RETRACTION_LENGTH"
#define _PROC_RETRACTION_SPEED "RETRACTION_SPEED"
#define _PROC_RETRACTION_ZHOP "RETRACTION_ZHOP"
#define _PROC_BED_LEVEL_AUTO "AUTO_LEVEL_BED"
#define _PROC_BED_RAISE "RAISE_BED"
#define _PROC_BED_HOME "HOME_BED"
#define _PROC_HEAD_HOME "HOME_HEAD"
#define __PROC_MATERIAL_MOVE(x) "MOVE_MATERIAL_" #x 
#define _PROC_MATERIAL_MOVE(x) "MOVE_MATERIAL_%u" 
#define _PROC_MATERIAL_MOVE_0 __PROC_MATERIAL_MOVE(0)
#define _PROC_MATERIAL_MOVE_1 __PROC_MATERIAL_MOVE(0)
#define _PROC_JERK_XY "JERK_XY"
#define _PROC_JERK_Z "JERK_Z"
#define _PROC_CURRENT_XY "XY_MAX_CURRENT"
#define _PROC_CURRENT_Z "Z_MAX_CURRENT"
#define _PROC_CURRENT_E "E_CURRENT"
#define _PROC_MATERIAL_UNLOAD "REMOVE_MATERIAL"
#define _PROC_MATERIAL_LOAD "INSERT_MATERIAL"
#define _PROC_MATERIAL_CHANGE "CHANGE_MATERIAL"

#define _META_CURRENT "current"
#define _META_TARGET "target"

#define _STEP_FIRMWARE_UPDATE_CHECKING "FIRMWARE_UPDATE_CHECKING"
#define _STEP_FIRMWARE_UPDATE_WRITING "FIRMWARE_UPDATE_WRITING"
#define _STEP_FIRMWARE_UPDATE_VERIFYING "FIRMWARE_UPDATE_VERIFYING"
#define _STEP_WAITING "WAITING"
#define _STEP_PRINTING "PRINTING"
#define _STEP_PRINT_SPEEDING "PRINT_SPEEDING"
#define _STEP_MOVING "MOVING"
#define _STEP_HOMEING "HOMEING"
#define _STEP_HOTEND_HEATING "HOTEND_HEATING"
#define _STEP_BED_HEATING "BED_HEATING"
#define _STEP_FAN_SPEEDING "FAN_SPEEDING"
#define _STEP_MATERIAL_FLOWING "MATERIAL_FLOWING"
#define _STEP_RETRACTION_SPEEDING "RETRACTION_SPEEDING"
#define _STEP_RETRACTION_LENGTHENING "RETRACTION_LENGTHENING"
#define _STEP_RETRACTION_HOPPING "RETRACTION_HOPPING"
#define _STEP_AUTOMATIC_BED_LEVELING "AUTOMATIC_BED_LEVELING"
#define _STEP_RAISING "RAISING"
#define _STEP_CURRENTING "CURRENTING"
#define _STEP_JERKING "JERKING"
#define _STEP_SWITCHING "SWITCHING"

#define _PROC_MSG_PRINTER_CLEANED "PRINTER_CLEANED"

static Eldbus_Proxy *__proxy = NULL;

static void _container_basic_variant(Eldbus_Message_Iter *parent, int type, ...)
{
	Eldbus_Message_Iter *child;
	va_list value;
	char sig[2] = { '\0' };

	sig[0] = type;
	child = eldbus_message_iter_container_new(parent, 'v', sig);
	va_start(value, type);
	eldbus_message_iter_arguments_vappend(child, sig, value);
	va_end(value);
	eldbus_message_iter_container_close(parent, child);
}

static void _container_dict_basic_variant_append(Eldbus_Message_Iter *array, int type, const char *key, ...) /* TODO rename something key/value */
{
	Eldbus_Message_Iter *value, *dict;
	va_list ap;
	char sig[2] = { '\0' };

	sig[0] = type;

	dict = eldbus_message_iter_container_new(array, 'e', NULL);	/* {			*/
	eldbus_message_iter_basic_append(dict, 's', key);		/*  s (key)		*/
	value = eldbus_message_iter_container_new(dict, 'v', sig);	/*  start variant	*/
	va_start(ap, key);
	eldbus_message_iter_arguments_vappend(value, sig, ap);		/*  v (value)		*/
	va_end(ap);
	eldbus_message_iter_container_close(dict, value);		/*  end variant		*/
	eldbus_message_iter_container_close(array, dict);		/* }			*/
}

void _meta_progress_free(void *meta EINA_UNUSED, void *data EINA_UNUSED)
{
	/* This is a dummy function, we dont' need to free anything, as there was no malloced data.
	 * If however we do not supply this function to ecore_event_add() ecore tries to free
	 * the meta that's not free-able */
}

static void _meta_progress_get(void *data, const void *key, Eldbus_Message_Iter *var)
{
	struct procedure_data *procedure = data;
	struct print_data *progress = procedure->meta; /* XXX rename to progress data | check meta_type if it is the correct type. */
	const char *skey = key;
	char *var_sig;

	if (!progress) {
		EINA_LOG_ERR("dial_data should not be null");
		return;
	}

	var_sig = eldbus_message_iter_signature_get(var);
	if (!strcmp(skey, _META_PROGRESS_JOBNAME)) {
		char *value = NULL;

		if (!eldbus_message_iter_arguments_get(var, "s", &value)) {/* TODO: check if value is leaking mem here */
			EINA_LOG_ERR("Message signature does not match \"s\", got %s", var_sig);
		} else {
			uint_fast16_t value_size = strlen(value) + 1;

			progress->jobname = realloc(progress->jobname, value_size);
			strncpy(progress->jobname, value, value_size);
		}
			
	} else if (!strcmp(skey, _META_PROGRESS_TIME)) {
		int32_t value = 0;

		if (!eldbus_message_iter_arguments_get(var, "i", &value))
			EINA_LOG_ERR("Message signature does not match \"i\", got %s", var_sig);
		else
			progress->time = value;
	} else if (!strcmp(skey, _META_PROGRESS_TIME_TOTAL)) {
		int32_t value = 0;

		if (!eldbus_message_iter_arguments_get(var, "i", &value))
			EINA_LOG_ERR("Message signature does not match \"i\", got %s", var_sig);
		else
			progress->total_time = value;
	}
	if (!strcmp(skey, _META_PROGRESS)) {
		double value = 0.0;

		if (!eldbus_message_iter_arguments_get(var, "d", &value))
			EINA_LOG_ERR("Message signature does not match \"d\", got %s", var_sig);
		else
			progress->value = value;
	}
	free(var_sig);

	ecore_event_add(procedure->event.type, procedure->meta, &_meta_progress_free, NULL);
}

static void _meta_cur_tar_get(void *data, const void *key, Eldbus_Message_Iter *var)
{
	struct procedure_data *procedure = data;
	struct settings_dial_data *dial_data = procedure->meta;
	const char *skey = key;
	char *var_sig;
	double value;

	if (!dial_data) {
		EINA_LOG_ERR("dial_data should not be null");
		return;
	}

	var_sig = eldbus_message_iter_signature_get(var);
	if (!strcmp(skey, _META_TARGET)) {
		if (!eldbus_message_iter_arguments_get(var, "d", &value))
			EINA_LOG_ERR("Message signature does not match \"d\", got %s", var_sig);
		else
			dial_data->value = value;
	} else if (!strcmp(skey, _META_CURRENT)) {
		if (!eldbus_message_iter_arguments_get(var, "d", &value))
			EINA_LOG_ERR("Message signature does not match \"d\", got %s", var_sig);
		else
			dial_data->value_end = value;
	}
	free(var_sig);

//	ecore_event_add(procedure->event.type, dial_data, NULL, NULL);
}

static void _on_start_print_ret(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending EINA_UNUSED)
{
	struct print_data *print = data;
	const char *errname, *errmsg;
	Eina_Bool print_started = EINA_FALSE;

	if (eldbus_message_error_get(msg, &errname, &errmsg)) {
		EINA_LOG_ERR("%s %s", errname, errmsg);
		return;
	}
	if (!eldbus_message_arguments_get(msg, "b", &print_started)) {
		EINA_LOG_ERR("Signature mistmatch, \"b\".");
		return;
	}
	if (print_started == EINA_TRUE) {
		EINA_LOG_INFO("Print has been successfully started");
		print->block = EINA_FALSE;
	} else {
		EINA_LOG_ERR("Unable to start print");
		/* TODO, if print start failed, invalidate all PRINTING pages */
		//ui_stack_page_invalidate(eulogium->navi, PAGE_PRINTING);
	}
}

static void _on_start_dial_ret(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending EINA_UNUSED)
{
	char *label = data;
	const char *errname, *errmsg;
	Eina_Bool procedure_started = EINA_FALSE;

	if (eldbus_message_error_get(msg, &errname, &errmsg)) {
		EINA_LOG_ERR("%s %s", errname, errmsg);
		return;
	}
	if (!eldbus_message_arguments_get(msg, "b", &procedure_started)) {
		EINA_LOG_ERR("Signature mistmatch, \"b\".");
		return;
	}
	if (procedure_started == EINA_TRUE) {
		EINA_LOG_INFO("Procedure %s has been successfully started", label);
	} else {
		EINA_LOG_ERR("Unable to start procedure %s", label);
		/* TODO, if tuning failed .. */
	}
}

Eina_Bool _print_progress_cleanup(void *data, Elm_Object_Item *eoi EINA_UNUSED)
{
	eulogium_print_data_clear(data);

	return EINA_TRUE;
}

void procedure_process_step(struct procedure_data *procedure, struct eulogium_data *eulogium)
{
	Evas_Object *content = NULL;
	Elm_Object_Item *navi_item = NULL;
	enum navi_page_state page_state = PAGE_NORMAL;

	if (!procedure)
		return;
	if (!procedure->step_active)
		return;

	/* XXX TODO build 'remember previous screen so we don't redraw the same' */
	EINA_LOG_CRIT("processing key %s step %s", procedure->key, procedure->step_active->key);
	if (procedure->step_active->step == STEP_FIRMWARE_UPDATE_WRITING) {
		procedure_metadata_poll_start(procedure); /* Poll for progress information, no signal on these */
		content = ui_widget_progress(eulogium->navi, procedure->meta, &procedure->event);
		page_state = PAGE_FIRMWARE;
	}
//	if (procedure->step_active->step == HEATUP_HOTEND) {
//		procedure_metadata_poll_start(procedure); /* Poll for progress information, no signal on these */
//		content = ui_widget_progress(eulogium->navi, procedure->meta, &procedure->event);
//		page_state = PAGE_PRINTING;
//	}
	if (procedure->step_active->step == STEP_PRINTING) {
		procedure_metadata_poll_start(procedure); /* Poll for progress information, no signal on these */
		content = ui_widget_progress(eulogium->navi, procedure->meta, &procedure->event);
		page_state = PAGE_PRINTING;
	}
	if (procedure->step_active->step == PROC_WAIT_FOR_CLEANUP) {
		content = ui_clean_print_bed(eulogium->navi);
	}

	if (!content)
		return;

	navi_item = elm_naviframe_item_simple_push(eulogium->navi, content);
	elm_object_item_data_set(navi_item, (void *)page_state); /* TODO remove? why is this still here */
	if (page_state == PAGE_PRINTING)
		elm_naviframe_item_pop_cb_set(navi_item, _print_progress_cleanup, eulogium);
}

void procedure_process_finish(struct procedure_data *procedure, struct eulogium_data *eulogium)
{
	if (!procedure)
		return;
	
	EINA_LOG_CRIT("finishing key %s", procedure->key);
	switch (procedure->proc_key) {
	case PROC_FIRMWARE_UPDATE:
		procedure_metadata_poll_stop(procedure);
		ui_stack_page_invalidate(eulogium->navi, PAGE_FIRMWARE);
		ui_stack_pop(eulogium->navi);
		break;
	case PROC_PRINT:
		procedure_metadata_poll_stop(procedure);
		ui_stack_page_invalidate(eulogium->navi, PAGE_PRINTING);
		ui_stack_pop(eulogium->navi);
		break;
	default:
		break;
	}
}

static struct procedure_msg print_msgs[] = {
	{
		.key = _PROC_MSG_PRINTER_CLEANED,
		.msg = PROC_MSG_PRINTER_CLEANED,
	}, { NULL }, /* sentinel */
};

static struct procedure_step steps_firmware_update[] = {
	{
		.key = _STEP_FIRMWARE_UPDATE_CHECKING,
		.step = STEP_FIRMWARE_UPDATE_CHECKING,
	}, {
		.key = _STEP_FIRMWARE_UPDATE_WRITING,
		.step = STEP_FIRMWARE_UPDATE_WRITING,
	}, {
		.key = _STEP_FIRMWARE_UPDATE_VERIFYING,
		.step = STEP_FIRMWARE_UPDATE_VERIFYING,
	}, { NULL }, /* sentinel */
};

static struct procedure_step steps_print[] = {
	{
		.key = _PROC_RUN_PRE_PRINT_SETUP,
		.step = PROC_RUN_PRE_PRINT_SETUP,
	}, {
		.key = _STEP_PRINTING,
		.step = STEP_PRINTING,
	}, {
		.key = _PROC_POST_PRINT,
		.step = PROC_POST_PRINT,
	}, {
		.key = _PROC_WAIT_FOR_CLEANUP,
		.step = PROC_WAIT_FOR_CLEANUP,
	}, { NULL }, /* sentinel */
};

static struct procedure_step steps_bed_temp_set[] = {
	{
		.key = _STEP_BED_HEATING,
		.step = STEP_HEATING,
	}, { NULL }, /* sentinel */
};

static struct procedure_step steps_hotend_temp_set[] = {
	{
		.key = _STEP_HOTEND_HEATING,
		.step = STEP_HEATING,
	}, { NULL }, /* sentinel */
};

static struct procedure_step steps_fan_speed_set[] = {
	{
		.key = _STEP_FAN_SPEEDING,
		.step = STEP_SPEEDING,
	}, { NULL }, /* sentinel */
};

static struct procedure_step steps_flow_rate_set[] = {
	{
		.key = _STEP_MATERIAL_FLOWING,
		.step = STEP_SPEEDING,
	}, { NULL }, /* sentinel */
};

static struct procedure_step steps_print_speed_set[] = {
	{
		.key = _STEP_PRINT_SPEEDING,
		.step = STEP_SPEEDING,
	}, { NULL }, /* sentinel */
};

static struct procedure_step steps_retraction_length_set[] = {
	{
		.key = _STEP_RETRACTION_LENGTHENING,
		.step = STEP_LENGTHENING,
	}, { NULL }, /* sentinel */
};

static struct procedure_step steps_retraction_speed_set[] = {
	{
		.key = _STEP_RETRACTION_SPEEDING,
		.step = STEP_SPEEDING,
	}, { NULL }, /* sentinel */
};

static struct procedure_step steps_retraction_zhop_set[] = {
	{
		.key = _STEP_RETRACTION_HOPPING,
		.step = STEP_HOPPING,
	}, { NULL }, /* sentinel */
};

static struct procedure_step steps_bed_level_auto[] = {
	{
		.key = _STEP_HOMEING,
		.step = STEP_HOMEING,
	}, {
		.key = _STEP_AUTOMATIC_BED_LEVELING,
		.step = STEP_AUTOMATIC_BED_LEVELING,
	}, {
		.key = _STEP_WAITING,
		.step = STEP_WAITING,
	}, { NULL }, /* sentinel */
};

static struct procedure_step steps_bed_raise[] = {
	{
		.key = _STEP_HOMEING,
		.step = STEP_HOMEING,
	}, {
		.key = _STEP_RAISING,
		.step = STEP_RAISING,
	}, {
		.key = _STEP_WAITING,
		.step = STEP_WAITING,
	}, { NULL }, /* sentinel */
};

static struct procedure_step steps_bed_home[] = {
	{
		.key = _STEP_HOMEING,
		.step = STEP_HOMEING,
	}, {
		.key = _STEP_WAITING,
		.step = STEP_WAITING,
	}, { NULL }, /* sentinel */
};

static struct procedure_step steps_head_home[] = {
	{
		.key = _STEP_HOMEING,
		.step = STEP_HOMEING,
	}, {
		.key = _STEP_WAITING,
		.step = STEP_WAITING,
	}, { NULL }, /* sentinel */
};

static struct procedure_step steps_move[] = {
	{
		.key = _STEP_MOVING,
		.step = STEP_MOVING,
	}, {
		.key = _STEP_WAITING,
		.step = STEP_WAITING,
	}, { NULL }, /* sentinel */
};

static struct procedure_step steps_jerk_xyz_set[] = {
	{
		.key = _STEP_JERKING,
		.step = STEP_JERKING,
	}, { NULL }, /* sentinel */
};

static struct procedure_step steps_current_xyze_set[] = {
	{
		.key = _STEP_CURRENTING,
		.step = STEP_CURRENTING,
	}, { NULL }, /* sentinel */
};

static struct procedure_step steps_hotend_active_set[] = {
	{
		.key = _STEP_SWITCHING,
		.step = STEP_SWITCHING,
	}, { NULL }, /* sentinel */
};

static struct procedure_step steps_material_unload[] = {
	{
		.key = _STEP_SWITCHING,
		.step = STEP_SWITCHING,
	}, { NULL }, /* sentinel */
};

static struct procedure_step steps_material_load[] = {
	{
		.key = _STEP_SWITCHING,
		.step = STEP_SWITCHING,
	}, { NULL }, /* sentinel */
};

static struct procedure_step steps_material_change[] = {
	{
		.key = _STEP_SWITCHING,
		.step = STEP_SWITCHING,
	}, { NULL }, /* sentinel */
};

static struct procedure_data procedures[] = {
	[PROC_FIRMWARE_UPDATE] = {
		.key = _PROC_FIRMWARE_UPDATE,
		.proc_key = PROC_FIRMWARE_UPDATE,
		.wizard = EINA_FALSE,
		.status = PROC_READY,
		.parser = _meta_progress_get,
		.executable = EINA_FALSE,
		.available = EINA_FALSE,
		._steps = steps_firmware_update,
		.step_active = NULL,
		.meta = NULL, /* struct progress_data */
		.event = {
			.in = 0.5,
			.timer = NULL,
			.type = 0,
		},
	},
	[PROC_PRINT] = {
		.key = _PROC_PRINT,
		.proc_key = PROC_PRINT,
		.wizard = EINA_FALSE,
		.status = PROC_READY,
		.parser = _meta_progress_get,
		.executable = EINA_FALSE,
		.available = EINA_FALSE,
		._steps = steps_print,
		.step_active = NULL,
		.meta = NULL, /* struct print_data */
		.event = { 
			.in = 0.5,
			.timer = NULL,
			.type = 0,
		},
	},
	[PROC_BED_HEATUP] = {
		.key = _PROC_BED_HEATUP,
		.proc_key = PROC_BED_HEATUP,
		.wizard = EINA_FALSE,
		.status = PROC_READY,
		.parser = _meta_cur_tar_get,
		.executable = EINA_FALSE,
		.available = EINA_FALSE,
		._steps = steps_bed_temp_set,
		.step_active = NULL,
		.meta = NULL,
		.event = { 
			.in = 0.0,
			.timer = NULL,
			.type = 0,
		},
	},
	[PROC_HOTEND_HEATUP_0] = {
		.key = _PROC_HOTEND_HEATUP_0,
		.proc_key = PROC_HOTEND_HEATUP_0,
		.wizard = EINA_FALSE,
		.status = PROC_READY,
		.parser = _meta_cur_tar_get,
		.executable = EINA_FALSE,
		.available = EINA_FALSE,
		._steps = steps_hotend_temp_set,
		.step_active = NULL,
		.meta = NULL,
		.event = { 
			.in = 0.0,
			.timer = NULL
		},
	},
	[PROC_HOTEND_HEATUP_1] = {
		.key = _PROC_HOTEND_HEATUP_1,
		.proc_key = PROC_HOTEND_HEATUP_1,
		.wizard = EINA_FALSE,
		.status = PROC_READY,
		.parser = _meta_cur_tar_get,
		.executable = EINA_FALSE,
		.available = EINA_FALSE,
		._steps = steps_hotend_temp_set,
		.step_active = NULL,
		.meta = NULL,
		.event = { 
			.in = 0.0,
			.timer = NULL,
			.type = 0,
		},
	},
	[PROC_HOTEND_ACTIVE_SET] = {
		.key = _PROC_HOTEND_ACTIVE_SET,
		.proc_key = PROC_HOTEND_ACTIVE_SET,
		.wizard = EINA_FALSE,
		.status = PROC_READY,
		.parser = _meta_cur_tar_get,
		.executable = EINA_FALSE,
		.available = EINA_FALSE,
		._steps = steps_hotend_active_set,
		.step_active = NULL,
		.meta = NULL,
		.event = { 
			.in = 0.0,
			.timer = NULL,
			.type = 0,
		},
	},
	[PROC_PRINT_SPEED] = {
		.key = _PROC_PRINT_SPEED,
		.proc_key = PROC_PRINT_SPEED,
		.wizard = EINA_FALSE,
		.status = PROC_READY,
		.parser = _meta_cur_tar_get,
		.executable = EINA_FALSE,
		.available = EINA_FALSE,
		._steps = steps_print_speed_set,
		.step_active = NULL,
		.meta = NULL,
		.event = { 
			.in = 0.0,
			.timer = NULL,
			.type = 0,
		},
	},
	[PROC_FAN_SPEED] = {
		.key = _PROC_FAN_SPEED,
		.proc_key = PROC_FAN_SPEED,
		.wizard = EINA_FALSE,
		.status = PROC_READY,
		.parser = _meta_cur_tar_get,
		.executable = EINA_FALSE,
		.available = EINA_FALSE,
		._steps = steps_fan_speed_set,
		.step_active = NULL,
		.meta = NULL,
		.event = { 
			.in = 0.0,
			.timer = NULL,
			.type = 0,
		},
	},
	[PROC_FLOW_RATE] = {
		.key = _PROC_FLOW_RATE,
		.proc_key = PROC_FLOW_RATE,
		.wizard = EINA_FALSE,
		.status = PROC_READY,
		.parser = _meta_cur_tar_get,
		.executable = EINA_FALSE,
		.available = EINA_FALSE,
		._steps = steps_flow_rate_set,
		.step_active = NULL,
		.meta = NULL,
		.event = { 
			.in = 0.0,
			.timer = NULL,
			.type = 0,
		},
	},
	[PROC_RETRACTION_LENGTH] = {
		.key = _PROC_RETRACTION_LENGTH,
		.proc_key = PROC_RETRACTION_LENGTH,
		.wizard = EINA_FALSE,
		.status = PROC_READY,
		.parser = _meta_cur_tar_get,
		.executable = EINA_FALSE,
		.available = EINA_FALSE,
		._steps = steps_retraction_length_set,
		.step_active = NULL,
		.meta = NULL,
		.event = { 
			.in = 0.0,
			.timer = NULL,
			.type = 0,
		},
	},
	[PROC_RETRACTION_SPEED] = {
		.key = _PROC_RETRACTION_SPEED,
		.proc_key = PROC_RETRACTION_SPEED,
		.wizard = EINA_FALSE,
		.status = PROC_READY,
		.parser = _meta_cur_tar_get,
		.executable = EINA_FALSE,
		.available = EINA_FALSE,
		._steps = steps_retraction_speed_set,
		.step_active = NULL,
		.meta = NULL,
		.event = { 
			.in = 0.0,
			.timer = NULL,
			.type = 0,
		},
	},
	[PROC_RETRACTION_ZHOP] = {
		.key = _PROC_RETRACTION_ZHOP,
		.proc_key = PROC_RETRACTION_ZHOP,
		.wizard = EINA_FALSE,
		.status = PROC_READY,
		.parser = _meta_cur_tar_get,
		.executable = EINA_FALSE,
		.available = EINA_FALSE,
		._steps = steps_retraction_zhop_set,
		.step_active = NULL,
		.meta = NULL,
		.event = { 
			.in = 0.0,
			.timer = NULL,
			.type = 0,
		},
	},
	[PROC_BED_LEVEL_AUTO] = {
		.key = _PROC_BED_LEVEL_AUTO,
		.proc_key = PROC_BED_LEVEL_AUTO,
		.wizard = EINA_FALSE,
		.status = PROC_READY,
		.parser = _meta_cur_tar_get,
		.executable = EINA_FALSE,
		.available = EINA_FALSE,
		._steps = steps_bed_level_auto,
		.step_active = NULL,
		.meta = NULL,
		.event = { 
			.in = 0.0,
			.timer = NULL,
			.type = 0,
		},
	},
	[PROC_BED_RAISE] = {
		.key = _PROC_BED_RAISE,
		.proc_key = PROC_BED_RAISE,
		.wizard = EINA_FALSE,
		.status = PROC_READY,
		.parser = _meta_cur_tar_get,
		.executable = EINA_FALSE,
		.available = EINA_FALSE,
		._steps = steps_bed_raise,
		.step_active = NULL,
		.meta = NULL,
		.event = { 
			.in = 0.0,
			.timer = NULL,
			.type = 0,
		},
	},
	[PROC_BED_HOME] = {
		.key = _PROC_BED_HOME,
		.proc_key = PROC_BED_HOME,
		.wizard = EINA_FALSE,
		.status = PROC_READY,
		.parser = _meta_cur_tar_get,
		.executable = EINA_FALSE,
		.available = EINA_FALSE,
		._steps = steps_bed_home,
		.step_active = NULL,
		.meta = NULL,
		.event = { 
			.in = 0.0,
			.timer = NULL,
			.type = 0,
		},
	},
	[PROC_BED_MOVE] = {
		.key = _PROC_BED_MOVE,
		.proc_key = PROC_BED_MOVE,
		.wizard = EINA_FALSE,
		.status = PROC_READY,
		.parser = NULL,
		.executable = EINA_FALSE,
		.available = EINA_FALSE,
		._steps = steps_move,
		.step_active = NULL,
		.meta = NULL,
		.event = { 
			.in = 0.0,
			.timer = NULL,
			.type = 0,
		},
	},
	[PROC_HEAD_HOME] = {
		.key = _PROC_HEAD_HOME,
		.proc_key = PROC_HEAD_HOME,
		.wizard = EINA_FALSE,
		.status = PROC_READY,
		.parser = _meta_cur_tar_get,
		.executable = EINA_FALSE,
		.available = EINA_FALSE,
		._steps = steps_head_home,
		.step_active = NULL,
		.meta = NULL,
		.event = { 
			.in = 0.0,
			.timer = NULL,
			.type = 0,
		},
	},
	[PROC_MATERIAL_MOVE_0] = {
		.key = _PROC_MATERIAL_MOVE_0,
		.proc_key = PROC_MATERIAL_MOVE_0,
		.wizard = EINA_FALSE,
		.status = PROC_READY,
		.parser = NULL,
		.executable = EINA_FALSE,
		.available = EINA_FALSE,
		._steps = steps_move,
		.step_active = NULL,
		.meta = NULL,
		.event = { 
			.in = 0.0,
			.timer = NULL,
			.type = 0,
		},
	},
	[PROC_MATERIAL_MOVE_1] = {
		.key = _PROC_MATERIAL_MOVE_1,
		.proc_key = PROC_MATERIAL_MOVE_1,
		.wizard = EINA_FALSE,
		.status = PROC_READY,
		.parser = NULL,
		.executable = EINA_FALSE,
		.available = EINA_FALSE,
		._steps = steps_move,
		.step_active = NULL,
		.meta = NULL,
		.event = { 
			.in = 0.0,
			.timer = NULL,
			.type = 0,
		},
	},
	[PROC_JERK_XY] = {
		.key = _PROC_JERK_XY,
		.proc_key = PROC_JERK_XY,
		.wizard = EINA_FALSE,
		.status = PROC_READY,
		.parser = _meta_cur_tar_get,
		.executable = EINA_FALSE,
		.available = EINA_FALSE,
		._steps = steps_jerk_xyz_set,
		.step_active = NULL,
		.meta = NULL,
		.event = { 
			.in = 0.0,
			.timer = NULL,
			.type = 0,
		},
	},
	[PROC_JERK_Z] = {
		.key = _PROC_JERK_Z,
		.proc_key = PROC_JERK_Z,
		.wizard = EINA_FALSE,
		.status = PROC_READY,
		.parser = _meta_cur_tar_get,
		.executable = EINA_FALSE,
		.available = EINA_FALSE,
		._steps = steps_jerk_xyz_set,
		.step_active = NULL,
		.meta = NULL,
		.event = { 
			.in = 0.0,
			.timer = NULL,
			.type = 0,
		},
	},
	[PROC_CURRENT_XY] = {
		.key = _PROC_CURRENT_XY,
		.proc_key = PROC_CURRENT_XY,
		.wizard = EINA_FALSE,
		.status = PROC_READY,
		.parser = _meta_cur_tar_get,
		.executable = EINA_FALSE,
		.available = EINA_FALSE,
		._steps = steps_current_xyze_set,
		.step_active = NULL,
		.meta = NULL,
		.event = { 
			.in = 0.0,
			.timer = NULL,
			.type = 0,
		},
	},
	[PROC_CURRENT_Z] = {
		.key = _PROC_CURRENT_Z,
		.proc_key = PROC_CURRENT_Z,
		.wizard = EINA_FALSE,
		.status = PROC_READY,
		.parser = _meta_cur_tar_get,
		.executable = EINA_FALSE,
		.available = EINA_FALSE,
		._steps = steps_current_xyze_set,
		.step_active = NULL,
		.meta = NULL,
		.event = { 
			.in = 0.0,
			.timer = NULL,
			.type = 0,
		},
	},
	[PROC_CURRENT_E] = {
		.key = _PROC_CURRENT_E,
		.proc_key = PROC_CURRENT_E,
		.wizard = EINA_FALSE,
		.status = PROC_READY,
		.parser = _meta_cur_tar_get,
		.executable = EINA_FALSE,
		.available = EINA_FALSE,
		._steps = steps_current_xyze_set,
		.step_active = NULL,
		.meta = NULL,
		.event = { 
			.in = 0.0,
			.timer = NULL,
			.type = 0,
		},
	},
	[PROC_MATERIAL_UNLOAD] = {
		.key = _PROC_MATERIAL_UNLOAD,
		.proc_key = PROC_MATERIAL_UNLOAD,
		.wizard = EINA_TRUE,
		.status = PROC_READY,
		.parser = NULL,
		.executable = EINA_FALSE,
		.available = EINA_FALSE,
		._steps = steps_material_unload,
		.step_active = NULL,
		.meta = NULL,
		.event = { 
			.in = 0.0,
			.timer = NULL,
			.type = 0,
		},
	},
	[PROC_MATERIAL_LOAD] = {
		.key = _PROC_MATERIAL_LOAD,
		.proc_key = PROC_MATERIAL_LOAD,
		.wizard = EINA_TRUE,
		.status = PROC_READY,
		.parser = NULL,
		.executable = EINA_FALSE,
		.available = EINA_FALSE,
		._steps = steps_material_load,
		.step_active = NULL,
		.meta = NULL,
		.event = { 
			.in = 0.0,
			.timer = NULL,
			.type = 0,
		},
	},
	[PROC_MATERIAL_CHANGE] = {
		.key = _PROC_MATERIAL_CHANGE,
		.proc_key = PROC_MATERIAL_CHANGE,
		.wizard = EINA_TRUE,
		.status = PROC_READY,
		.parser = NULL,
		.executable = EINA_FALSE,
		.available = EINA_FALSE,
		._steps = steps_material_change,
		.step_active = NULL,
		.meta = NULL,
		.event = { 
			.in = 0.0,
			.timer = NULL,
			.type = 0,
		},
	},
};

void *procedure_meta_data_get(struct procedure_data *procedure)
{
	return procedure->meta;
}

enum meta_type procedure_meta_type_get(struct procedure_data *procedure)
{
	return procedure->type;
}

void procedure_meta_set(struct procedure_data *procedure, enum meta_type type, void *data)
{
	procedure->type = type;
	procedure->meta = data;
}

const struct procedure_step *procedure_step_get(const struct procedure_data *proc, const char *key)
{
	uint_fast16_t i;

	if (!proc)
		return NULL;

	for (i = 0; proc->_steps[i].key; i++) {
		if (!strcmp(proc->_steps[i].key, key))
			return &proc->_steps[i];
	}

	return NULL;
};

struct procedure_data *procedure_get(const char *key)
{
	enum procedure_key i;

	for (i = PROC_NONE + 1; procedures[i].key; i++) {
		if (!strcmp(procedures[i].key, key))
			return &procedures[i];
	}

	return NULL;
};

Eldbus_Pending *procedure_message(const struct procedure_data *proc, const struct procedure_msg *msg)
{
	return eldbus_proxy_call(__proxy, "messageProcedure", NULL, NULL, -1, "ss", proc->key, msg->key);
}

Eldbus_Pending *procedure_led_brightness_set(const Evas_Object *dial)
{
	//struct settings_dial_data *dial_data;

//	dial_data = evas_object_data_get(dial, "dial_data");
//	eldbus_proxy_call(dial_data->proxy, "SetBrightness", _on_dial_units_update_ret, dial, -1, "");
}

Eldbus_Pending *procedure_print_printer_cleaned(void) /* XXX pass procedure step? */
{
	return eldbus_proxy_call(__proxy, "messageProcedure", on_method_generic_bool_ret, NULL, -1, "ss", _PROC_PRINT, _PROC_MSG_PRINTER_CLEANED);
}

Eldbus_Pending *procedure_start_simple(const enum procedure_key proc_key)
{
	Eldbus_Message *msg;
	Eldbus_Message_Iter *iter, *array;

	msg = eldbus_proxy_method_call_new(__proxy, "startProcedure");
	iter = eldbus_message_iter_get(msg);

	/* Compose msg sa{sv} */
	eldbus_message_iter_basic_append(iter, 's', procedures[proc_key].key);
	array = eldbus_message_iter_container_new(iter, 'a', "{sv}");

	_container_dict_basic_variant_append(array, 's', "dummy", "");

	eldbus_message_iter_container_close(iter, array);

	return eldbus_proxy_send(__proxy, msg, on_method_generic_bool_ret, NULL, -1);
}

/* TODO half of the content of this procedure is generic and could be gotten from the procedure if it where a parameter. This can be made much more generic. */
Eldbus_Pending *procedure_print_start(const struct print_data *print)
{
	Eldbus_Message *msg;
	Eldbus_Message_Iter *iter, *array;

	msg = eldbus_proxy_method_call_new(__proxy, "startProcedure");
	iter = eldbus_message_iter_get(msg);

	/* Compose msg sa{sv} */
	eldbus_message_iter_basic_append(iter, 's', "PRINT");
	array = eldbus_message_iter_container_new(iter, 'a', "{sv}");

	_container_dict_basic_variant_append(array, 's', "name", print->jobname);
	_container_dict_basic_variant_append(array, 's', "url", print->url);

	eldbus_message_iter_container_close(iter, array);

	return eldbus_proxy_send(__proxy, msg, _on_start_print_ret, print, -1);
}

/* TODO, add resend/retry if actual value does not match current value */
// XXX procedure_start_target(const enum procedure_key proc_key);
Eldbus_Pending *procedure_target_set(const enum procedure_key proc_key)
{
	Eldbus_Message *msg;
	Eldbus_Message_Iter *iter, *array;
	struct procedure_data *procedure = &procedures[proc_key];
	struct settings_dial_data *dial_data = procedure->meta;

	msg = eldbus_proxy_method_call_new(__proxy, "startProcedure");
	iter = eldbus_message_iter_get(msg);

	/* Compose msg sa{sv} */
	printf("Prockey: %s\n", procedure->key);
	eldbus_message_iter_basic_append(iter, 's', procedure->key);
	array = eldbus_message_iter_container_new(iter, 'a', "{sv}");

	_container_dict_basic_variant_append(array, 'd', "target", dial_data->value);

	eldbus_message_iter_container_close(iter, array);

	return eldbus_proxy_send(__proxy, msg, _on_start_dial_ret, dial_data->label, -1);
}

static Eina_Bool _cb_timer_procedure_metadata_poll(void *data)
{
	struct procedure_data *procedure = data;

	if (!procedure)
		return ECORE_CALLBACK_CANCEL;

	procedure_metadata_get(procedure);

	return ECORE_CALLBACK_RENEW;
}

void procedure_metadata_poll_start(struct procedure_data *procedure)
{
	if (procedure->event.timer) {
		EINA_LOG_WARN("Starting poll timer when already running for procedure %s.", procedure->key);
		return; /* Timer already running */
	}
	procedure->event.timer = ecore_timer_add(procedure->event.in, _cb_timer_procedure_metadata_poll, procedure);
	if (!procedure->event.timer)
		EINA_LOG_CRIT("Unable to create metadata polling timer for procedure %s.", procedure->key);
}

void procedure_metadata_poll_stop(struct procedure_data *procedure)
{
	if (procedure->event.timer)
		ecore_timer_del(procedure->event.timer);
	else
		EINA_LOG_CRIT("Unable to delete metadata polling timer for procedure %s.", procedure->key);
}

Eldbus_Pending *procedure_metadata_get(const struct procedure_data *procedure)
{
	return eldbus_proxy_call(__proxy, "getProcedureMetaData", on_method_get_procedure_metadata_ret, procedure, -1, "s", procedure->key);
}

Eldbus_Pending *procedure_metadata_key_get(enum procedure_key proc_key)
{
	return eldbus_proxy_call(__proxy, "getProcedureMetaData", on_method_get_procedure_metadata_ret, &procedures[proc_key], -1, "s", procedures[proc_key].key);
}

void procedure_metadata_getall(void)
{
	enum procedure_key i;

	for (i = PROC_NONE; i < PROC_LAST; i++)
		if (procedures[i].meta)
			procedure_metadata_key_get(i);
};

struct procedure_data *procedures_init(Eldbus_Proxy *proxy)
{
	enum procedure_key i;

	__proxy = proxy;

	for (i = PROC_NONE; i < PROC_LAST; i++) {
		if (procedures[i].key)
			procedures[i].event.type = ecore_event_type_new();
	}

	/* TODO: we probably should do something here to prepare all procedures and their meta data
	 * so that we can do the getall here and drop the function altogether.
	 */
	return procedures;
};

void procedures_shutdown(void)
{
	eldbus_proxy_unref(__proxy);
};