void
cd_sensor_unlock_async (CdSensor *sensor,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
CdSensorArgyllPrivate *priv = cd_sensor_argyll_get_private (sensor);
CdSensorTaskData *data;
GTask *task = NULL;
g_return_if_fail (CD_IS_SENSOR (sensor));
task = g_task_new (sensor, cancellable, callback, user_data);
/* set state */
data = g_new0 (CdSensorTaskData, 1);
data->sensor = g_object_ref (sensor);
g_task_set_task_data (task, data, (GDestroyNotify) cd_sensor_task_data_free);
/* wait for exit */
data->exit_id = g_signal_connect (priv->spawn,
"exit",
G_CALLBACK (cd_sensor_unlock_exit_cb),
task);
/* kill spotread */
if (!cd_spawn_kill (priv->spawn)) {
g_task_return_new_error (task,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_INTERNAL,
"failed to kill spotread");
g_object_unref (task);
return;
}
}
/**
* cd_sensor_get_id:
**/
const gchar *
cd_sensor_get_id (CdSensor *sensor)
{
CdSensorPrivate *priv = GET_PRIVATE (sensor);
g_return_val_if_fail (CD_IS_SENSOR (sensor), NULL);
return priv->id;
}
void
cd_sensor_unlock_async (CdSensor *sensor,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_autoptr(GTask) task = NULL;
g_return_if_fail (CD_IS_SENSOR (sensor));
task = g_task_new (sensor, cancellable, callback, user_data);
g_task_run_in_thread (task, cd_sensor_unlock_thread_cb);
}
void
cd_sensor_get_sample_async (CdSensor *sensor,
CdSensorCap cap,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_autoptr(GTask) task = NULL;
g_return_if_fail (CD_IS_SENSOR (sensor));
task = g_task_new (sensor, cancellable, callback, user_data);
g_task_set_task_data (task, GUINT_TO_POINTER (cap), NULL);
g_task_run_in_thread (task, cd_sensor_dtp94_sample_thread_cb);
}
void
cd_sensor_set_options_async (CdSensor *sensor,
GHashTable *options,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
CdSensorDummyPrivate *priv = cd_sensor_dummy_get_private (sensor);
GList *l;
const gchar *key_name;
GVariant *value;
g_autoptr(GTask) task = NULL;
g_autoptr(GList) keys = NULL;
g_return_if_fail (CD_IS_SENSOR (sensor));
task = g_task_new (sensor, cancellable, callback, user_data);
/* look for any keys we recognise */
keys = g_hash_table_get_keys (options);
for (l = keys; l != NULL; l = l->next) {
key_name = (const gchar *) l->data;
value = g_hash_table_lookup (options, key_name);
if (g_strcmp0 (g_variant_get_type_string (value), "d") != 0) {
g_task_return_new_error (task,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_NO_SUPPORT,
"unexpected type '%s' not supported",
g_variant_get_type_string (value));
return;
}
if (g_strcmp0 (key_name, "sample[red]") == 0) {
priv->sample_fake.R = g_variant_get_double (value);
} else if (g_strcmp0 (key_name, "sample[green]") == 0) {
priv->sample_fake.G = g_variant_get_double (value);
} else if (g_strcmp0 (key_name, "sample[blue]") == 0) {
priv->sample_fake.B = g_variant_get_double (value);
} else {
g_task_return_new_error (task,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_NO_SUPPORT,
"option '%s' is not supported",
key_name);
return;
}
}
/* success */
g_task_return_boolean (task, TRUE);
}
/**
* _cd_sensor_lock_async:
*
* Lock the sensor. You don't ever need to call this, and this method
* should only be used from the internal self check program.
**/
void
_cd_sensor_lock_async (CdSensor *sensor,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_return_if_fail (CD_IS_SENSOR (sensor));
g_return_if_fail (sensor->priv->desc != NULL);
/* proxy up */
if (sensor->priv->desc->lock_async) {
sensor->priv->desc->lock_async (sensor,
cancellable,
callback,
user_data);
}
}
/**
* cd_sensor_set_id:
**/
static void
cd_sensor_set_id (CdSensor *sensor, const gchar *id)
{
gchar *id_tmp;
g_return_if_fail (CD_IS_SENSOR (sensor));
g_free (sensor->priv->id);
/* make sure object path is sane */
id_tmp = cd_main_ensure_dbus_path (id);
sensor->priv->object_path = g_build_filename (COLORD_DBUS_PATH,
"sensors",
id_tmp,
NULL);
sensor->priv->id = g_strdup (id);
g_free (id_tmp);
}
/**
* cd_sensor_set_id:
**/
static void
cd_sensor_set_id (CdSensor *sensor, const gchar *id)
{
CdSensorPrivate *priv = GET_PRIVATE (sensor);
g_autofree gchar *id_tmp = NULL;
g_return_if_fail (CD_IS_SENSOR (sensor));
g_free (priv->id);
/* make sure object path is sane */
id_tmp = cd_main_ensure_dbus_path (id);
priv->object_path = g_build_filename (COLORD_DBUS_PATH,
"sensors",
id_tmp,
NULL);
priv->id = g_strdup (id);
}
gboolean
cd_sensor_unlock_finish (CdSensor *sensor, GAsyncResult *res, GError **error)
{
GSimpleAsyncResult *simple;
gboolean ret = TRUE;
g_return_val_if_fail (CD_IS_SENSOR (sensor), FALSE);
g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (res), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
simple = G_SIMPLE_ASYNC_RESULT (res);
if (g_simple_async_result_propagate_error (simple, error)) {
ret = FALSE;
goto out;
}
out:
return ret;
}
void
cd_sensor_get_sample_async (CdSensor *sensor,
CdSensorCap cap,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_autoptr(GTask) task = NULL;
g_return_if_fail (CD_IS_SENSOR (sensor));
task = g_task_new (sensor, cancellable, callback, user_data);
if (cap == CD_SENSOR_CAP_AMBIENT) {
g_task_run_in_thread (task, cd_sensor_munki_get_ambient_thread_cb);
} else if (cap == CD_SENSOR_CAP_LCD ||
cap == CD_SENSOR_CAP_LED ||
cap == CD_SENSOR_CAP_CRT) {
g_task_run_in_thread (task, cd_sensor_munki_sample_thread_cb);
}
}
/**
* _cd_sensor_lock_finish:
*
* Finish locking the sensor. You don't ever need to call this, and this
* method should only be used from the internal self check program.
**/
gboolean
_cd_sensor_lock_finish (CdSensor *sensor,
GAsyncResult *res,
GError **error)
{
gboolean ret = TRUE;
g_return_val_if_fail (CD_IS_SENSOR (sensor), FALSE);
g_return_val_if_fail (sensor->priv->desc != NULL, FALSE);
/* proxy up */
if (sensor->priv->desc->lock_finish) {
ret = sensor->priv->desc->lock_finish (sensor,
res,
error);
}
cd_sensor_set_locked (sensor, TRUE);
return ret;
}
void
cd_sensor_get_sample_async (CdSensor *sensor,
CdSensorCap cap,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_autoptr(GTask) task = NULL;
g_return_if_fail (CD_IS_SENSOR (sensor));
task = g_task_new (sensor, cancellable, callback, user_data);
/* set state */
cd_sensor_set_state (sensor, CD_SENSOR_STATE_MEASURING);
/* just complete in idle */
if (cap != CD_SENSOR_CAP_AMBIENT)
g_timeout_add_seconds (2, (GSourceFunc) cd_sensor_get_sample_wait_cb, task);
else
g_timeout_add_seconds (2, (GSourceFunc) cd_sensor_get_ambient_wait_cb, task);
}
/**
* cd_sensor_get_id:
**/
const gchar *
cd_sensor_get_id (CdSensor *sensor)
{
g_return_val_if_fail (CD_IS_SENSOR (sensor), NULL);
return sensor->priv->id;
}
/**
* cd_sensor_get_object_path:
**/
const gchar *
cd_sensor_get_object_path (CdSensor *sensor)
{
g_return_val_if_fail (CD_IS_SENSOR (sensor), NULL);
return sensor->priv->object_path;
}
void
cd_sensor_get_sample_async (CdSensor *sensor,
CdSensorCap cap,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
CdSensorArgyllPrivate *priv = cd_sensor_argyll_get_private (sensor);
CdSensorTaskData *data;
GTask *task = NULL;
const gchar *envp[] = { "ARGYLL_NOT_INTERACTIVE=1", NULL };
gboolean ret;
g_autoptr(GError) error = NULL;
g_autoptr(GPtrArray) argv = NULL;
g_return_if_fail (CD_IS_SENSOR (sensor));
task = g_task_new (sensor, cancellable, callback, user_data);
/* set state */
data = g_new0 (CdSensorTaskData, 1);
data->sensor = g_object_ref (sensor);
g_task_set_task_data (task, data, (GDestroyNotify) cd_sensor_task_data_free);
/* set state */
cd_sensor_set_state (sensor, CD_SENSOR_STATE_MEASURING);
/* connect before spotread produces values */
data->exit_id = g_signal_connect (priv->spawn,
"exit",
G_CALLBACK (cd_sensor_get_sample_exit_cb),
task);
data->stdout_id = g_signal_connect (priv->spawn,
"stdout",
G_CALLBACK (cd_sensor_get_sample_stdout_cb),
task);
/* if spotread is not already running then execute */
if (!cd_spawn_is_running (priv->spawn)) {
argv = g_ptr_array_new_with_free_func (g_free);
g_ptr_array_add (argv, g_strdup ("/usr/bin/spotread"));
g_ptr_array_add (argv, g_strdup ("-d"));
g_ptr_array_add (argv, g_strdup_printf ("-c%i", priv->communication_port));
g_ptr_array_add (argv, g_strdup ("-N")); //no autocal
g_ptr_array_add (argv, g_strdup (cd_sensor_get_y_arg_for_cap (cap)));
g_ptr_array_add (argv, NULL);
ret = cd_spawn_argv (priv->spawn,
(gchar **) argv->pdata,
(gchar **) envp,
&error);
if (!ret) {
g_task_return_new_error (task,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_INTERNAL,
"%s", error->message);
return;
}
} else {
cd_spawn_send_stdin (priv->spawn, "");
}
/* cover the case where spotread crashes */
data->timeout_id = g_timeout_add (CD_SENSOR_ARGYLL_MAX_SAMPLE_TIME,
(GSourceFunc) cd_sensor_get_sample_timeout_cb,
task);
}
