/**
* cd_sensor_get_sample_cb:
**/
static void
cd_sensor_get_sample_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GVariant *result = NULL;
g_autoptr(CdColorXYZ) sample = NULL;
CdSensor *sensor = CD_SENSOR (source_object);
CdSensorPrivate *priv = GET_PRIVATE (sensor);
GDBusMethodInvocation *invocation = (GDBusMethodInvocation *) user_data;
g_autoptr(GError) error = NULL;
/* set here to avoid every sensor doing this */
cd_sensor_set_state (sensor, CD_SENSOR_STATE_IDLE);
/* get the result */
sample = priv->desc->get_sample_finish (sensor, res, &error);
if (sample == NULL) {
g_dbus_method_invocation_return_gerror (invocation, error);
return;
}
/* return value */
g_debug ("returning value %f, %f, %f", sample->X, sample->Y, sample->Z);
result = g_variant_new ("(ddd)", sample->X, sample->Y, sample->Z);
g_dbus_method_invocation_return_value (invocation, result);
}
/**
* cd_sensor_unlock_cb:
**/
static void
cd_sensor_unlock_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
CdSensor *sensor = CD_SENSOR (source_object);
CdSensorPrivate *priv = GET_PRIVATE (sensor);
GDBusMethodInvocation *invocation = (GDBusMethodInvocation *) user_data;
gboolean ret;
g_autoptr(GError) error = NULL;
/* set here to avoid every sensor doing this */
cd_sensor_set_state (sensor, CD_SENSOR_STATE_IDLE);
/* get the result */
if (priv->desc != NULL &&
priv->desc->unlock_finish != NULL) {
ret = priv->desc->unlock_finish (sensor, res, &error);
if (!ret) {
g_dbus_method_invocation_return_error (invocation,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_NO_SUPPORT,
"failed to unlock: %s",
error->message);
return;
}
}
cd_sensor_set_locked (sensor, FALSE);
g_dbus_method_invocation_return_value (invocation, NULL);
}
/**
* cd_sensor_finalize:
**/
static void
cd_sensor_finalize (GObject *object)
{
CdSensor *sensor = CD_SENSOR (object);
CdSensorPrivate *priv = sensor->priv;
if (priv->registration_id > 0) {
g_debug ("CdSensor: Unregister interface %i on %s",
priv->registration_id,
priv->object_path);
g_dbus_connection_unregister_object (priv->connection,
priv->registration_id);
}
if (priv->watcher_id != 0)
g_bus_unwatch_name (priv->watcher_id);
g_free (priv->model);
g_free (priv->vendor);
g_free (priv->serial);
g_free (priv->id);
g_free (priv->object_path);
g_hash_table_unref (priv->options);
g_hash_table_unref (priv->metadata);
#ifdef HAVE_GUSB
g_object_unref (priv->usb_ctx);
g_object_unref (priv->device_list);
#endif
#ifdef HAVE_GUDEV
if (priv->device != NULL)
g_object_unref (priv->device);
#endif
G_OBJECT_CLASS (cd_sensor_parent_class)->finalize (object);
}
/**
* cd_sensor_new:
**/
CdSensor *
cd_sensor_new (void)
{
CdSensor *sensor;
sensor = g_object_new (CD_TYPE_SENSOR, NULL);
return CD_SENSOR (sensor);
}
static void
cd_sensor_unlock_thread_cb (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
CdSensor *sensor = CD_SENSOR (object);
CdSensorMunkiPrivate *priv = cd_sensor_munki_get_private (sensor);
gboolean ret = FALSE;
g_autoptr(GError) error = NULL;
/* stop watching the dial */
libusb_cancel_transfer (priv->transfer_interrupt);
libusb_cancel_transfer (priv->transfer_state);
/* close */
if (priv->device != NULL) {
if (!g_usb_device_close (priv->device, &error)) {
g_task_return_new_error (task,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_INTERNAL,
"%s", error->message);
return;
}
g_clear_object (&priv->device);
}
/* success */
g_task_return_boolean (task, TRUE);
}
/**
* cd_sensor_get_sample_cb:
**/
static void
cd_sensor_get_sample_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GVariant *result = NULL;
CdColorXYZ *sample;
CdSensor *sensor = CD_SENSOR (source_object);
GDBusMethodInvocation *invocation = (GDBusMethodInvocation *) user_data;
GError *error = NULL;
/* get the result */
sample = sensor->priv->desc->get_sample_finish (sensor, res, &error);
if (sample == NULL) {
g_dbus_method_invocation_return_gerror (invocation,
error);
g_error_free (error);
goto out;
}
/* return value */
g_debug ("returning value %f, %f, %f",
sample->X,
sample->Y,
sample->Z);
result = g_variant_new ("(ddd)",
sample->X,
sample->Y,
sample->Z);
g_dbus_method_invocation_return_value (invocation, result);
out:
if (sample != NULL)
cd_color_xyz_free (sample);
}
static void
cd_sensor_munki_sample_thread_cb (GSimpleAsyncResult *res,
GObject *object,
GCancellable *cancellable)
{
g_autoptr(GError) error = NULL;
CdSensor *sensor = CD_SENSOR (object);
// CdSensorMunkiPrivate *priv = cd_sensor_munki_get_private (sensor);
/* no hardware support */
if (task->current_cap == CD_SENSOR_CAP_PROJECTOR) {
g_set_error_literal (&error, CD_SENSOR_ERROR,
CD_SENSOR_ERROR_NO_SUPPORT,
"MUNKI cannot measure in projector mode");
g_task_return_new_error (task,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_INTERNAL,
"%s", error->message);
goto out;
}
/* set state */
cd_sensor_set_state_in_idle (sensor, CD_SENSOR_STATE_MEASURING);
/* save result */
task->sample = cd_color_xyz_new ();
g_task_return_error (task, NULL);
out:
/* set state */
cd_sensor_set_state_in_idle (sensor, CD_SENSOR_STATE_IDLE);
}
/**
* cd_sensor_unlock_cb:
**/
static void
cd_sensor_unlock_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
CdSensor *sensor = CD_SENSOR (source_object);
gboolean ret;
GDBusMethodInvocation *invocation = (GDBusMethodInvocation *) user_data;
GError *error = NULL;
/* get the result */
if (sensor->priv->desc != NULL &&
sensor->priv->desc->unlock_finish != NULL) {
ret = sensor->priv->desc->unlock_finish (sensor, res, &error);
if (!ret) {
g_dbus_method_invocation_return_error (invocation,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_NO_SUPPORT,
"failed to unlock: %s",
error->message);
g_error_free (error);
goto out;
}
}
cd_sensor_set_locked (sensor, FALSE);
g_dbus_method_invocation_return_value (invocation, NULL);
out:
return;
}
static gboolean
cd_sensor_get_sample_wait_cb (GTask *task)
{
CdSensor *sensor = CD_SENSOR (g_task_get_source_object (task));
CdSensorDummyPrivate *priv = cd_sensor_dummy_get_private (sensor);
CdColorXYZ *sample = NULL;
g_autoptr(GError) error = NULL;
/* never setup */
if (priv->transform_fake == NULL) {
g_task_return_new_error (task,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_NO_SUPPORT,
"no fake transfor set up");
return G_SOURCE_REMOVE;
}
/* run the sample through the profile */
sample = cd_color_xyz_new ();
cmsDoTransform (priv->transform_fake, &priv->sample_fake, sample, 1);
/* emulate */
cd_sensor_button_pressed (sensor);
/* just return without a problem */
g_task_return_pointer (task, sample, (GDestroyNotify) cd_color_xyz_free);
return G_SOURCE_REMOVE;
}
/**
* cd_sensor_unlock_quietly_cb:
**/
static void
cd_sensor_unlock_quietly_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
CdSensor *sensor = CD_SENSOR (source_object);
CdSensorPrivate *priv = GET_PRIVATE (sensor);
gboolean ret;
g_autoptr(GError) error = NULL;
/* set here to avoid every sensor doing this */
cd_sensor_set_state (sensor, CD_SENSOR_STATE_IDLE);
/* get the result */
if (priv->desc != NULL &&
priv->desc->unlock_finish != NULL) {
ret = priv->desc->unlock_finish (sensor, res, &error);
if (!ret) {
g_warning ("failed to unlock: %s",
error->message);
return;
}
}
cd_sensor_set_locked (sensor, FALSE);
}
static void
cd_sensor_unlock_thread_cb (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
CdSensor *sensor = CD_SENSOR (source_object);
CdSensorDtp94Private *priv = cd_sensor_dtp94_get_private (sensor);
g_autoptr(GError) error = NULL;
/* close */
if (priv->device != NULL) {
if (!g_usb_device_close (priv->device, &error)) {
g_task_return_new_error (task,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_INTERNAL,
"%s", error->message);
return;
}
g_clear_object (&priv->device);
}
/* success */
g_task_return_boolean (task, TRUE);
}
static void
cd_sensor_dtp94_lock_thread_cb (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
CdSensor *sensor = CD_SENSOR (source_object);
CdSensorDtp94Private *priv = cd_sensor_dtp94_get_private (sensor);
g_autoptr(GError) error = NULL;
g_autofree gchar *serial = NULL;
/* try to find the USB device */
priv->device = cd_sensor_open_usb_device (sensor,
0x01, /* config */
0x00, /* interface */
&error);
if (priv->device == NULL) {
g_task_return_new_error (task,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_INTERNAL,
"%s", error->message);
return;
}
/* set state */
cd_sensor_set_state_in_idle (sensor, CD_SENSOR_STATE_STARTING);
/* do startup sequence */
if (!dtp94_device_setup (priv->device, &error)) {
g_task_return_new_error (task,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_INTERNAL,
"%s", error->message);
return;
}
/* get serial */
serial = dtp94_device_get_serial (priv->device, &error);
if (serial == NULL) {
g_task_return_new_error (task,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_NO_DATA,
"%s", error->message);
return;
}
cd_sensor_set_serial (sensor, serial);
/* success */
g_task_return_boolean (task, TRUE);
}
/**
* cd_sensor_get_property:
**/
static void
cd_sensor_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
CdSensor *sensor = CD_SENSOR (object);
CdSensorPrivate *priv = sensor->priv;
switch (prop_id) {
case PROP_OBJECT_PATH:
g_value_set_string (value, priv->object_path);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
/**
* cd_sensor_set_property:
**/
static void
cd_sensor_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
{
CdSensor *sensor = CD_SENSOR (object);
CdSensorPrivate *priv = sensor->priv;
switch (prop_id) {
case PROP_OBJECT_PATH:
g_free (priv->object_path);
priv->object_path = g_strdup (g_value_get_string (value));
break;
case PROP_MODEL:
g_free (priv->model);
priv->model = g_strdup (g_value_get_string (value));
break;
case PROP_VENDOR:
g_free (priv->vendor);
priv->vendor = g_strdup (g_value_get_string (value));
break;
case PROP_ID:
cd_sensor_set_id (sensor, g_value_get_string (value));
break;
case PROP_NATIVE:
priv->native = g_value_get_boolean (value);
break;
case PROP_LOCKED:
priv->locked = g_value_get_boolean (value);
break;
case PROP_STATE:
priv->state = g_value_get_uint (value);
break;
case PROP_MODE:
priv->mode = g_value_get_uint (value);
break;
case PROP_KIND:
cd_sensor_set_kind (sensor, g_value_get_uint (value));
break;
case PROP_CAPS:
priv->caps = g_value_get_uint64 (value);
break;
case PROP_SERIAL:
cd_sensor_set_serial (sensor, g_value_get_string (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
/**
* cd_sensor_dbus_get_property:
**/
static GVariant *
cd_sensor_dbus_get_property (GDBusConnection *connection_, const gchar *sender,
const gchar *object_path, const gchar *interface_name,
const gchar *property_name, GError **error,
gpointer user_data)
{
CdSensor *sensor = CD_SENSOR (user_data);
CdSensorPrivate *priv = GET_PRIVATE (sensor);
if (g_strcmp0 (property_name, CD_SENSOR_PROPERTY_ID) == 0)
return g_variant_new_string (priv->id);
if (g_strcmp0 (property_name, CD_SENSOR_PROPERTY_KIND) == 0)
return g_variant_new_string (cd_sensor_kind_to_string (priv->kind));
if (g_strcmp0 (property_name, CD_SENSOR_PROPERTY_STATE) == 0)
return g_variant_new_string (cd_sensor_state_to_string (priv->state));
if (g_strcmp0 (property_name, CD_SENSOR_PROPERTY_MODE) == 0)
return g_variant_new_string (cd_sensor_cap_to_string (priv->mode));
if (g_strcmp0 (property_name, CD_SENSOR_PROPERTY_SERIAL) == 0)
return cd_sensor_get_nullable_for_string (priv->serial);
if (g_strcmp0 (property_name, CD_SENSOR_PROPERTY_MODEL) == 0)
return cd_sensor_get_nullable_for_string (priv->model);
if (g_strcmp0 (property_name, CD_SENSOR_PROPERTY_VENDOR) == 0)
return cd_sensor_get_nullable_for_string (priv->vendor);
if (g_strcmp0 (property_name, CD_SENSOR_PROPERTY_NATIVE) == 0)
return g_variant_new_boolean (priv->native);
if (g_strcmp0 (property_name, CD_SENSOR_PROPERTY_LOCKED) == 0)
return g_variant_new_boolean (priv->locked);
if (g_strcmp0 (property_name, CD_SENSOR_PROPERTY_EMBEDDED) == 0)
return g_variant_new_boolean (priv->embedded);
if (g_strcmp0 (property_name, CD_SENSOR_PROPERTY_CAPABILITIES) == 0)
return cd_sensor_get_variant_for_caps (priv->caps);
if (g_strcmp0 (property_name, CD_SENSOR_PROPERTY_OPTIONS) == 0)
return cd_sensor_get_options_as_variant (sensor);
if (g_strcmp0 (property_name, CD_SENSOR_PROPERTY_METADATA) == 0)
return cd_sensor_get_metadata_as_variant (sensor);
/* return an error */
g_set_error (error,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_INTERNAL,
"failed to get sensor property %s",
property_name);
return NULL;
}
/**
* cd_sensor_set_options_cb:
**/
static void
cd_sensor_set_options_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
gboolean ret;
CdSensor *sensor = CD_SENSOR (source_object);
CdSensorPrivate *priv = GET_PRIVATE (sensor);
GDBusMethodInvocation *invocation = (GDBusMethodInvocation *) user_data;
g_autoptr(GError) error = NULL;
/* get the result */
ret = priv->desc->set_options_finish (sensor, res, &error);
if (!ret) {
g_dbus_method_invocation_return_gerror (invocation, error);
return;
}
g_dbus_method_invocation_return_value (invocation, NULL);
}
static void
cd_sensor_munki_get_ambient_thread_cb (GSimpleAsyncResult *res,
GObject *object,
GCancellable *cancellable)
{
CdSensor *sensor = CD_SENSOR (object);
g_autoptr(GError) error = NULL;
// CdSensorMunkiPrivate *priv = cd_sensor_munki_get_private (sensor);
/* no hardware support */
if (cd_sensor_get_mode (sensor) != CD_SENSOR_CAP_AMBIENT) {
g_set_error_literal (&error, CD_SENSOR_ERROR,
CD_SENSOR_ERROR_NO_SUPPORT,
"Cannot measure ambient light in this mode (turn dial!)");
g_task_return_new_error (task,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_INTERNAL,
"%s", error->message);
goto out;
}
/*
* ioctl(3, USBDEVFS_SUBMITURB or USBDEVFS_SUBMITURB32, {type=3, endpoint=129, status=0, flags=0, buffer_length=1096, actual_length=0, start_frame=0, number_of_packets=0, error_count=0, signr=0, usercontext=(nil), buffer=00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ) = 0
* ioctl(3, USBDEVFS_CONTROL or USBDEVFS_CONTROL32, {requesttype=64, request=128, value=0, index=0, length=12, timeout=2000, data=00 00 01 00 b7 3e 00 00 02 00 00 00 ) = 12
*
* ioctl(3, USBDEVFS_SUBMITURB or USBDEVFS_SUBMITURB32, {type=3, endpoint=129, status=0, flags=0, buffer_length=548, actual_length=0, start_frame=0, number_of_packets=0, error_count=0, signr=0, usercontext=(nil), buffer=d0 a3 9d 00 d0 a3 9d 00 00 00 00 00 00 00 00 00 00 d0 86 40 bf c6 fa 21 a4 4b 61 40 0b 24 0c d6 7a 29 04 40 91 3a 0e c7 f9 28 04 40 c0 b1 55 bc 9b 28 04 40 b9 d3 41 53 86 6a 07 40 df 23 db 4d 0c e3 06 40 20 5c bf 4d b2 53 05 40 5f 28 38 74 26 44 07 40 e9 45 b7 e4 2f a5 08 40 bb a2 87 d7 8c db 07 40 34 90 30 b1 f3 a1 06 40 b0 8f fa 63 84 98 05 40 35 1f 09 07 97 47 04 40 53 ac 8a be ) = 0
*
* ioctl(3, USBDEVFS_REAPURBNDELAY or USBDEVFS_REAPURBNDELAY32, {type=3, endpoint=129, status=0, flags=0, buffer_length=548, actual_length=548, start_frame=0, number_of_packets=0, error_count=0, signr=0, usercontext=(nil), buffer=de 07 da 07 d6 07 d8 07 d6 07 16 08 29 0b 79 0d 22 12 f2 17 b4 1c 31 20 4b 22 e2 22 7b 22 a8 21 93 20 eb 1e 2d 1d fe 1b 1c 1b e5 19 69 19 c8 19 b5 19 8a 18 16 17 a4 15 86 14 ac 13 e8 12 22 12 20 12 bf 12 8e 13 d2 13 de 13 ea 13 fb 13 39 14 89 14 bd 14 ec 14 8b 15 78 16 69 17 99 18 ca 19 97 1a 14 1b 6f 1b b5 1b 7f 1c 98 1d 59 1e a9 1e af 1e 71 1e d2 1d db 1c c1 1b d4 1a 50 1a 46 1a }) = 0
* write(1, " Result is XYZ: 126.685284 136.9"..., 91 Result is XYZ: 126.685284 136.946975 206.789116, D50 Lab: 112.817679 -7.615524 -49.589593
) = 91
* write(1, " Ambient = 430.2 Lux, CCT = 1115"..., 54 Ambient = 430.2 Lux, CCT = 11152K (Delta E 9.399372)
*/
/* set state */
cd_sensor_set_state_in_idle (sensor, CD_SENSOR_STATE_MEASURING);
/* save result */
g_task_return_error (task, NULL);
out:
/* set state */
cd_sensor_set_state_in_idle (sensor, CD_SENSOR_STATE_IDLE);
}
/**
* cd_sensor_munki_refresh_state_transfer_cb:
**/
static void
cd_sensor_munki_refresh_state_transfer_cb (struct libusb_transfer *transfer)
{
CdSensor *sensor = CD_SENSOR (transfer->user_data);
guint8 *reply = transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE;
if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
g_warning ("did not succeed");
goto out;
}
/* sensor position and button task */
switch (reply[0]) {
case MUNKI_DIAL_POSITION_PROJECTOR:
cd_sensor_set_mode (sensor, CD_SENSOR_CAP_PROJECTOR);
break;
case MUNKI_DIAL_POSITION_SURFACE:
cd_sensor_set_mode (sensor, CD_SENSOR_CAP_PRINTER);
break;
case MUNKI_DIAL_POSITION_CALIBRATION:
cd_sensor_set_mode (sensor, CD_SENSOR_CAP_CALIBRATION);
break;
case MUNKI_DIAL_POSITION_AMBIENT:
cd_sensor_set_mode (sensor, CD_SENSOR_CAP_AMBIENT);
break;
case MUNKI_DIAL_POSITION_UNKNOWN:
cd_sensor_set_mode (sensor, CD_SENSOR_CAP_UNKNOWN);
break;
default:
break;
}
g_debug ("dial now %s, button now %s",
cd_sensor_cap_to_string (cd_sensor_get_mode (sensor)),
munki_button_state_to_string (reply[1]));
cd_sensor_debug_data (CD_SENSOR_DEBUG_MODE_RESPONSE,
transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE,
transfer->actual_length);
out:
g_free (transfer->buffer);
}
/**
* cd_sensor_get_spectrum_cb:
**/
static void
cd_sensor_get_spectrum_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
CdSensor *sensor = CD_SENSOR (source_object);
CdSensorPrivate *priv = GET_PRIVATE (sensor);
GDBusMethodInvocation *invocation = (GDBusMethodInvocation *) user_data;
GVariant *result = NULL;
GVariantBuilder data;
guint i;
g_autoptr(CdSpectrum) sp = NULL;
g_autoptr(GError) error = NULL;
/* set here to avoid every sensor doing this */
cd_sensor_set_state (sensor, CD_SENSOR_STATE_IDLE);
/* get the result */
sp = priv->desc->get_spectrum_finish (sensor, res, &error);
if (sp == NULL) {
g_dbus_method_invocation_return_gerror (invocation, error);
return;
}
/* build data array */
g_variant_builder_init (&data, G_VARIANT_TYPE ("ad"));
for (i = 0; i < cd_spectrum_get_size (sp); i++) {
g_variant_builder_add (&data, "d",
cd_spectrum_get_value (sp, i));
}
/* return value */
g_debug ("returning value %f, %f, [%u]",
cd_spectrum_get_start (sp),
cd_spectrum_get_end (sp),
cd_spectrum_get_size (sp));
result = g_variant_new ("(ddad)",
cd_spectrum_get_start (sp),
cd_spectrum_get_end (sp),
&data);
g_dbus_method_invocation_return_value (invocation, result);
}
/**
* cd_sensor_set_options_cb:
**/
static void
cd_sensor_set_options_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
gboolean ret;
CdSensor *sensor = CD_SENSOR (source_object);
GDBusMethodInvocation *invocation = (GDBusMethodInvocation *) user_data;
GError *error = NULL;
/* get the result */
ret = sensor->priv->desc->set_options_finish (sensor, res, &error);
if (!ret) {
g_dbus_method_invocation_return_gerror (invocation,
error);
g_error_free (error);
goto out;
}
g_dbus_method_invocation_return_value (invocation, NULL);
out:
return;
}
/**
* cd_sensor_name_vanished_cb:
**/
static void
cd_sensor_name_vanished_cb (GDBusConnection *connection,
const gchar *name,
gpointer user_data)
{
CdSensor *sensor = CD_SENSOR (user_data);
/* dummy */
g_debug ("locked sender has vanished without doing Unlock()!");
if (sensor->priv->desc == NULL ||
sensor->priv->desc->unlock_async == NULL) {
cd_sensor_set_locked (sensor, FALSE);
goto out;
}
/* no longer valid */
sensor->priv->desc->unlock_async (sensor,
NULL,
cd_sensor_unlock_quietly_cb,
NULL);
out:
sensor->priv->watcher_id = 0;
}
/**
* cd_sensor_munki_transfer_cb:
**/
static void
cd_sensor_munki_transfer_cb (struct libusb_transfer *transfer)
{
guint32 timestamp;
CdSensor *sensor = CD_SENSOR (transfer->user_data);
guint8 *reply = transfer->buffer;
if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
g_warning ("did not succeed");
return;
}
cd_sensor_debug_data (CD_SENSOR_DEBUG_MODE_RESPONSE,
transfer->buffer + LIBUSB_CONTROL_SETUP_SIZE,
transfer->actual_length);
timestamp = (reply[7] << 24) + (reply[6] << 16) + (reply[5] << 8) + (reply[4] << 0);
/* we only care when the button is pressed */
if (reply[0] == MUNKI_COMMAND_BUTTON_RELEASED) {
g_debug ("ignoring button released");
goto out;
}
if (reply[0] == MUNKI_COMMAND_DIAL_ROTATE) {
g_warning ("dial rotate at %ims", timestamp);
} else if (reply[0] == MUNKI_COMMAND_BUTTON_PRESSED) {
g_debug ("button pressed at %ims", timestamp);
cd_sensor_button_pressed (sensor);
}
/* get the device task */
cd_sensor_munki_refresh_state (sensor, NULL);
out:
/* get the next bit of data */
g_free (transfer->buffer);
cd_sensor_munki_submit_transfer (sensor);
}
/**
* cd_sensor_unlock_quietly_cb:
**/
static void
cd_sensor_unlock_quietly_cb (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
CdSensor *sensor = CD_SENSOR (source_object);
gboolean ret;
GError *error = NULL;
/* get the result */
if (sensor->priv->desc != NULL &&
sensor->priv->desc->unlock_finish != NULL) {
ret = sensor->priv->desc->unlock_finish (sensor, res, &error);
if (!ret) {
g_warning ("failed to unlock: %s",
error->message);
g_error_free (error);
goto out;
}
}
cd_sensor_set_locked (sensor, FALSE);
out:
return;
}
static void
cd_sensor_dtp94_sample_thread_cb (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
CdSensor *sensor = CD_SENSOR (source_object);
CdSensorCap cap = GPOINTER_TO_UINT (task_data);
CdSensorDtp94Private *priv = cd_sensor_dtp94_get_private (sensor);
CdColorXYZ *sample;
g_autoptr(GError) error = NULL;
/* take a measurement from the sensor */
cd_sensor_set_state_in_idle (sensor, CD_SENSOR_STATE_MEASURING);
sample = dtp94_device_take_sample (priv->device, cap, &error);
if (sample == NULL) {
g_task_return_new_error (task,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_NO_DATA,
"%s", error->message);
return;
}
g_task_return_pointer (task, sample, NULL);
}
/**
* cd_sensor_dbus_method_call:
**/
static void
cd_sensor_dbus_method_call (GDBusConnection *connection, const gchar *sender,
const gchar *object_path, const gchar *interface_name,
const gchar *method_name, GVariant *parameters,
GDBusMethodInvocation *invocation, gpointer user_data)
{
CdSensorCap cap;
CdSensor *sensor = CD_SENSOR (user_data);
CdSensorPrivate *priv = sensor->priv;
const gchar *cap_tmp = NULL;
gboolean ret;
gchar *key;
GError *error = NULL;
GHashTable *options = NULL;
GVariantIter iter;
GVariant *result = NULL;
GVariant *value;
/* return '' */
if (g_strcmp0 (method_name, "Lock") == 0) {
g_debug ("CdSensor %s:Lock()", sender);
/* check locked */
if (priv->locked) {
g_dbus_method_invocation_return_error (invocation,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_ALREADY_LOCKED,
"sensor is already locked");
goto out;
}
/* require auth */
ret = cd_main_sender_authenticated (connection,
sender,
"org.freedesktop.color-manager.sensor-lock",
&error);
if (!ret) {
g_dbus_method_invocation_return_error (invocation,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_FAILED_TO_AUTHENTICATE,
"%s", error->message);
g_error_free (error);
goto out;
}
/* watch this bus name */
priv->watcher_id = g_bus_watch_name (G_BUS_TYPE_SYSTEM,
sender,
G_BUS_NAME_WATCHER_FLAGS_NONE,
NULL,
cd_sensor_name_vanished_cb,
sensor,
NULL);
/* no support */
if (sensor->priv->desc == NULL ||
sensor->priv->desc->lock_async == NULL) {
cd_sensor_set_locked (sensor, TRUE);
g_dbus_method_invocation_return_value (invocation, NULL);
goto out;
}
/* proxy */
sensor->priv->desc->lock_async (sensor,
NULL,
cd_sensor_lock_cb,
invocation);
goto out;
}
if (g_strcmp0 (method_name, "Unlock") == 0) {
g_debug ("CdSensor %s:Unlock()", sender);
/* check locked */
if (!priv->locked) {
g_dbus_method_invocation_return_error (invocation,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_NOT_LOCKED,
"sensor is not yet locked");
goto out;
}
/* require auth */
ret = cd_main_sender_authenticated (connection,
sender,
"org.freedesktop.color-manager.sensor-lock",
&error);
if (!ret) {
g_dbus_method_invocation_return_error (invocation,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_FAILED_TO_AUTHENTICATE,
"%s", error->message);
g_error_free (error);
goto out;
}
/* un-watch this bus name */
if (priv->watcher_id != 0) {
g_bus_unwatch_name (priv->watcher_id);
priv->watcher_id = 0;
}
/* no support */
if (sensor->priv->desc == NULL ||
sensor->priv->desc->unlock_async == NULL) {
cd_sensor_set_locked (sensor, FALSE);
g_dbus_method_invocation_return_value (invocation, NULL);
goto out;
}
/* proxy */
sensor->priv->desc->unlock_async (sensor,
NULL,
cd_sensor_unlock_cb,
invocation);
goto out;
}
/* return 'ddd,d' */
if (g_strcmp0 (method_name, "GetSample") == 0) {
g_debug ("CdSensor %s:GetSample()", sender);
/* check locked */
if (!priv->locked) {
g_dbus_method_invocation_return_error (invocation,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_NOT_LOCKED,
"sensor is not yet locked");
goto out;
}
/* check idle */
if (priv->state != CD_SENSOR_STATE_IDLE) {
g_dbus_method_invocation_return_error (invocation,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_IN_USE,
"sensor not idle: %s",
cd_sensor_state_to_string (priv->state));
goto out;
}
/* no support */
if (sensor->priv->desc == NULL ||
sensor->priv->desc->get_sample_async == NULL) {
g_dbus_method_invocation_return_error (invocation,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_NO_SUPPORT,
"no sensor->get_sample");
goto out;
}
/* get the type */
g_variant_get (parameters, "(&s)", &cap_tmp);
cap = cd_sensor_cap_from_string (cap_tmp);
if (cap == CD_SENSOR_CAP_UNKNOWN) {
g_dbus_method_invocation_return_error (invocation,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_INTERNAL,
"cap '%s' unknown",
cap_tmp);
goto out;
}
/* proxy */
sensor->priv->desc->get_sample_async (sensor,
cap,
NULL,
cd_sensor_get_sample_cb,
invocation);
goto out;
}
/* return '' */
if (g_strcmp0 (method_name, "SetOptions") == 0) {
g_debug ("CdSensor %s:SetOptions()", sender);
/* check locked */
if (!priv->locked) {
g_dbus_method_invocation_return_error (invocation,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_NOT_LOCKED,
"sensor is not yet locked");
goto out;
}
/* check idle */
if (priv->state != CD_SENSOR_STATE_IDLE) {
g_dbus_method_invocation_return_error (invocation,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_IN_USE,
"sensor not idle: %s",
cd_sensor_state_to_string (priv->state));
goto out;
}
/* no support */
if (sensor->priv->desc == NULL ||
sensor->priv->desc->set_options_async == NULL) {
g_dbus_method_invocation_return_error (invocation,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_NO_SUPPORT,
"no sensor options support");
goto out;
}
/* unwrap the parameters into a hash table */
options = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, (GDestroyNotify) g_variant_unref);
result = g_variant_get_child_value (parameters, 0);
g_variant_iter_init (&iter, result);
while (g_variant_iter_next (&iter, "{sv}", &key, &value))
g_hash_table_insert (options, key, value);
/* proxy */
sensor->priv->desc->set_options_async (sensor,
options,
NULL,
cd_sensor_set_options_cb,
invocation);
goto out;
}
/* we suck */
g_critical ("failed to process sensor method %s", method_name);
out:
if (options != NULL)
g_hash_table_unref (options);
if (result != NULL)
g_variant_unref (result);
}
static void
cd_sensor_munki_lock_thread_cb (GSimpleAsyncResult *res,
GObject *object,
GCancellable *cancellable)
{
CdSensor *sensor = CD_SENSOR (object);
CdSensorMunkiPrivate *priv = cd_sensor_munki_get_private (sensor);
gboolean ret = FALSE;
g_autoptr(GError) error = NULL;
gint retval;
guint8 buffer[36];
libusb_device_handle *handle;
/* try to find the USB device */
priv->device = cd_sensor_open_usb_device (sensor,
0x01, /* config */
0x00, /* interface */
&error);
if (priv->device == NULL) {
g_task_return_new_error (task,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_INTERNAL,
"%s", error->message);
goto out;
}
/* attach to the default mainloop */
ret = cd_usb_attach_to_context (priv->usb, NULL, &error);
if (!ret) {
g_task_return_new_error (task, CD_SENSOR_ERROR,
CD_SENSOR_ERROR_NO_SUPPORT,
"failed to attach to mainloop: %s",
error->message);
goto out;
}
/* get firmware parameters */
handle = cd_usb_get_device_handle (priv->usb);
retval = libusb_control_transfer (handle,
LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE,
MUNKI_REQUEST_FIRMWARE_PARAMS,
0, 0, buffer, 24, 2000);
if (retval < 0) {
g_task_return_new_error (task, CD_SENSOR_ERROR,
CD_SENSOR_ERROR_NO_SUPPORT,
"failed to get firmware parameters: %s",
libusb_strerror (retval));
goto out;
}
priv->firmware_revision = g_strdup_printf ("%i.%i",
cd_buffer_read_uint32_le (buffer),
cd_buffer_read_uint32_le (buffer+4));
priv->tick_duration = cd_buffer_read_uint32_le (buffer+8);
priv->min_int = cd_buffer_read_uint32_le (buffer+0x0c);
priv->eeprom_blocks = cd_buffer_read_uint32_le (buffer+0x10);
priv->eeprom_blocksize = cd_buffer_read_uint32_le (buffer+0x14);
/* get chip ID */
retval = libusb_control_transfer (handle,
LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE,
MUNKI_REQUEST_CHIP_ID,
0, 0, buffer, 8, 2000);
if (retval < 0) {
g_task_return_new_error (task, CD_SENSOR_ERROR,
CD_SENSOR_ERROR_NO_SUPPORT,
"failed to get chip id parameters: %s",
libusb_strerror (retval));
goto out;
}
priv->chip_id = g_strdup_printf ("%02x-%02x%02x%02x%02x%02x%02x%02x",
buffer[0], buffer[1], buffer[2], buffer[3],
buffer[4], buffer[5], buffer[6], buffer[7]);
/* get version string */
priv->version_string = g_new0 (gchar, 36);
retval = libusb_control_transfer (handle,
LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE,
MUNKI_REQUEST_VERSION_STRING,
0, 0, (guint8*) priv->version_string, 36, 2000);
if (retval < 0) {
g_task_return_new_error (task, CD_SENSOR_ERROR,
CD_SENSOR_ERROR_NO_SUPPORT,
"failed to get version string: %s",
libusb_strerror (retval));
goto out;
}
/* get serial number */
ret = cd_sensor_munki_get_eeprom_data (sensor,
COLORMUNKI_EEPROM_OFFSET_SERIAL_NUMBER,
buffer, 10, &error);
if (!ret) {
g_task_return_new_error (task,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_INTERNAL,
"%s", error->message);
goto out;
}
cd_sensor_set_serial (sensor, (const gchar*) buffer);
/* print details */
g_debug ("Chip ID\t%s", priv->chip_id);
g_debug ("Serial number\t%s", buffer);
g_debug ("Version\t%s", priv->version_string);
g_debug ("Firmware\tfirmware_revision=%s, tick_duration=%i, min_int=%i, eeprom_blocks=%i, eeprom_blocksize=%i",
priv->firmware_revision, priv->tick_duration, priv->min_int, priv->eeprom_blocks, priv->eeprom_blocksize);
/* do unknown cool stuff */
ret = cd_sensor_munki_random (sensor, &error);
if (!ret) {
g_assert (error != NULL);
g_task_return_new_error (task,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_INTERNAL,
"%s", error->message);
goto out;
}
out:
/* set state */
cd_sensor_set_state_in_idle (sensor, CD_SENSOR_STATE_IDLE);
}
