/**
* cd_sensor_set_state:
* @sensor: a valid #CdSensor instance
* @state: the sensor state, e.g %CD_SENSOR_STATE_IDLE
*
* Sets the device state.
**/
void
cd_sensor_set_state (CdSensor *sensor, CdSensorState state)
{
sensor->priv->state = state;
cd_sensor_dbus_emit_property_changed (sensor,
"State",
g_variant_new_string (cd_sensor_state_to_string (state)));
}
/**
* cd_sensor_set_state:
* @sensor: a valid #CdSensor instance
* @state: the sensor state, e.g %CD_SENSOR_STATE_IDLE
*
* Sets the device state.
**/
void
cd_sensor_set_state (CdSensor *sensor, CdSensorState state)
{
CdSensorPrivate *priv = GET_PRIVATE (sensor);
/* invalidate */
if (priv->set_state_id > 0) {
g_source_remove (priv->set_state_id);
priv->set_state_id = 0;
}
priv->state = state;
cd_sensor_dbus_emit_property_changed (sensor,
"State",
g_variant_new_string (cd_sensor_state_to_string (state)));
}
/**
* 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_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);
}
