static gboolean create_thumbnail (GIOSchedulerJob *job, GCancellable *cancellable, gpointer user_data) { GSimpleAsyncResult *result = user_data; GFile *file = G_FILE (g_async_result_get_source_object (G_ASYNC_RESULT (result))); GnomeDesktopThumbnailFactory *factory; GFileInfo *info; gchar *uri; GdkPixbuf *pixbuf; guint64 mtime; uri = g_file_get_uri (file); info = g_file_query_info (file, ATTRIBUTES_FOR_THUMBNAIL, G_FILE_QUERY_INFO_NONE, NULL, NULL); /* we don't care about reporting errors here, just fail the * thumbnail. */ if (info == NULL) { g_simple_async_result_set_op_res_gboolean (result, FALSE); goto out; } mtime = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_TIME_MODIFIED); factory = gnome_desktop_thumbnail_factory_new (GNOME_DESKTOP_THUMBNAIL_SIZE_NORMAL); pixbuf = gnome_desktop_thumbnail_factory_generate_thumbnail (factory, uri, g_file_info_get_content_type (info)); if (pixbuf != NULL) { gnome_desktop_thumbnail_factory_save_thumbnail (factory, pixbuf, uri, (time_t) mtime); g_simple_async_result_set_op_res_gboolean (result, TRUE); } else { g_simple_async_result_set_op_res_gboolean (result, FALSE); } g_object_unref (info); g_object_unref (file); g_object_unref (factory); g_clear_object (&pixbuf); out: g_simple_async_result_complete_in_idle (result); g_object_unref (result); return FALSE; }
static void nwdmat_ready (MMPortSerialAt *port, GAsyncResult *res, CustomInitContext *ctx) { const gchar *response; GError *error = NULL; response = mm_port_serial_at_command_finish (port, res, &error); if (error) { if (g_error_matches (error, MM_SERIAL_ERROR, MM_SERIAL_ERROR_RESPONSE_TIMEOUT)) { custom_init_step (ctx); goto out; } mm_dbg ("(Novatel) Error flipping secondary ports to AT mode: %s", error->message); } /* Finish custom_init */ g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE); custom_init_context_complete_and_free (ctx); out: if (error) g_error_free (error); }
static void unmount_callback(DBusGProxy *proxy, GError *error, gpointer user_data) { AsyncData* data = (AsyncData*)user_data; GSimpleAsyncResult* res; if(error) { error = g_udisks_error_to_gio_error(error); res = g_simple_async_result_new_from_error(data->mnt, data->callback, data->user_data, error); g_error_free(error); } else { res = g_simple_async_result_new(data->mnt, data->callback, data->user_data, NULL); g_simple_async_result_set_op_res_gboolean(res, TRUE); } g_simple_async_result_complete(res); g_object_unref(res); g_object_unref(data->mnt); g_object_unref(data->proxy); g_slice_free(AsyncData, data); }
static void gom_resource_save_cb (GomAdapter *adapter, gpointer user_data) { GSimpleAsyncResult *simple = user_data; GomResource *resource; gboolean ret; GError *error = NULL; GAsyncQueue *queue; g_return_if_fail(GOM_IS_ADAPTER(adapter)); g_return_if_fail(G_IS_SIMPLE_ASYNC_RESULT(simple)); resource = GOM_RESOURCE(g_async_result_get_source_object(G_ASYNC_RESULT(simple))); g_assert(GOM_IS_RESOURCE(resource)); queue = g_object_get_data(G_OBJECT(simple), "queue"); if (!(ret = gom_resource_do_save(resource, adapter, &error))) { g_simple_async_result_take_error(simple, error); } g_simple_async_result_set_op_res_gboolean(simple, ret); if (!queue) g_simple_async_result_complete_in_idle(simple); else g_async_queue_push(queue, GINT_TO_POINTER(TRUE)); g_object_unref(resource); }
static void telit_custom_init (MMPortProbe *probe, MMPortSerialAt *port, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { MMDevice *device; GUdevDevice *udevDevice; TelitCustomInitContext *ctx; device = mm_port_probe_peek_device (probe); udevDevice = mm_port_probe_peek_port (probe); ctx = g_slice_new (TelitCustomInitContext); ctx->result = g_simple_async_result_new (G_OBJECT (probe), callback, user_data, telit_custom_init); ctx->probe = g_object_ref (probe); ctx->port = g_object_ref (port); ctx->cancellable = cancellable ? g_object_ref (cancellable) : NULL; ctx->getportcfg_done = FALSE; ctx->getportcfg_retries = 3; /* If the device is tagged for supporting #PORTCFG do the custom init */ if (g_udev_device_get_property_as_boolean (udevDevice, "ID_MM_TELIT_PORTS_TAGGED")) { telit_custom_init_step (ctx); return; } g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE); telit_custom_init_context_complete_and_free (ctx); }
static void sierra_custom_init_step (SierraCustomInitContext *ctx) { /* If cancelled, end */ if (g_cancellable_is_cancelled (ctx->cancellable)) { mm_dbg ("(Sierra) no need to keep on running custom init in (%s)", mm_port_get_device (MM_PORT (ctx->port))); g_simple_async_result_set_error (ctx->result, MM_CORE_ERROR, MM_CORE_ERROR_CANCELLED, "Custom initialization cancelled"); sierra_custom_init_context_complete_and_free (ctx); return; } if (ctx->retries == 0) { mm_dbg ("(Sierra) Couldn't get port type hints"); g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE); sierra_custom_init_context_complete_and_free (ctx); return; } ctx->retries--; mm_at_serial_port_queue_command ( ctx->port, "ATI", 3, FALSE, /* raw */ ctx->cancellable, (MMAtSerialResponseFn)gcap_ready, ctx); }
static void soup_input_stream_close_async (GInputStream *stream, int io_priority, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GSimpleAsyncResult *result; gboolean success; GError *error = NULL; result = g_simple_async_result_new (G_OBJECT (stream), callback, user_data, soup_input_stream_close_async); success = soup_input_stream_close (stream, cancellable, &error); g_simple_async_result_set_op_res_gboolean (result, success); if (error) { g_simple_async_result_set_from_error (result, error); g_error_free (error); } g_simple_async_result_complete_in_idle (result); g_object_unref (result); }
static void cgclass_update_ready (MMBaseModem *self, GAsyncResult *res, SetAllowedModesContext *ctx) { GError *error = NULL; mm_base_modem_at_command_finish (MM_BASE_MODEM (self), res, &error); if (error) { /* Let the error be critical. */ g_simple_async_result_take_error (ctx->result, error); set_allowed_modes_context_complete_and_free (ctx); return; } if (!ctx->wwsm_command) { g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE); set_allowed_modes_context_complete_and_free (ctx); return; } mm_base_modem_at_command (MM_BASE_MODEM (self), ctx->wwsm_command, 3, FALSE, (GAsyncReadyCallback)wwsm_update_ready, ctx); }
static void setup_flow_control (MMIfaceModem *self, GAsyncReadyCallback callback, gpointer user_data) { GSimpleAsyncResult *result; gchar *cmd; guint flow_control = 1; /* Default flow control: XON/XOFF */ switch (mm_base_modem_get_product_id (MM_BASE_MODEM (self)) & 0xFFFF) { case 0x0021: flow_control = 2; /* Telit IMC modems support only RTS/CTS mode */ break; default: break; } cmd = g_strdup_printf ("+IFC=%u,%u", flow_control, flow_control); mm_base_modem_at_command (MM_BASE_MODEM (self), cmd, 3, FALSE, NULL, NULL); result = g_simple_async_result_new (G_OBJECT (self), callback, user_data, setup_flow_control); g_simple_async_result_set_op_res_gboolean (result, TRUE); g_simple_async_result_complete_in_idle (result); g_object_unref (result); g_free (cmd); }
static void send_async_finished (GInputStream *stream) { SoupInputStreamPrivate *priv = SOUP_INPUT_STREAM_GET_PRIVATE (stream); GSimpleAsyncResult *result; GError *error = NULL; if (!g_cancellable_set_error_if_cancelled (priv->cancellable, &error)) set_error_if_http_failed (priv->msg, &error); priv->got_headers_cb = NULL; priv->finished_cb = NULL; soup_input_stream_done_io (stream); result = priv->result; priv->result = NULL; g_simple_async_result_set_op_res_gboolean (result, error == NULL); if (error) { g_simple_async_result_set_from_error (result, error); g_error_free (error); } g_simple_async_result_complete (result); }
static void close_async_done (GOutputStream *stream) { SoupOutputStreamPrivate *priv = SOUP_OUTPUT_STREAM_GET_PRIVATE (stream); GSimpleAsyncResult *result; GError *error = NULL; result = priv->result; priv->result = NULL; if (g_cancellable_set_error_if_cancelled (priv->cancellable, &error) || set_error_if_http_failed (priv->msg, &error)) { g_simple_async_result_set_from_error (result, error); g_error_free (error); } else g_simple_async_result_set_op_res_gboolean (result, TRUE); priv->finished_cb = NULL; priv->cancelled_cb = NULL; soup_output_stream_done_io (stream); g_simple_async_result_complete (result); g_object_unref (result); }
static void catch_resource_group_fetch_cb (GObject *object, GAsyncResult *result, gpointer user_data) { CatchResourceGroupPrivate *priv; CatchResourceGroup *group; GSimpleAsyncResult *simple = user_data; gboolean ret = FALSE; GError *error = NULL; ENTRY; g_return_if_fail(G_IS_SIMPLE_ASYNC_RESULT(simple)); group = CATCH_RESOURCE_GROUP(g_async_result_get_source_object(user_data)); g_return_if_fail(CATCH_IS_RESOURCE_GROUP(group)); priv = group->priv; if (priv->group) { ret = gom_resource_group_fetch_finish(GOM_RESOURCE_GROUP(object), result, &error); } else { g_assert_not_reached(); } if (!ret) { g_simple_async_result_take_error(simple, error); } g_simple_async_result_set_op_res_gboolean(simple, ret); g_simple_async_result_complete_in_idle(simple); g_object_unref(simple); EXIT; }
void mm_broadband_bearer_hso_report_connection_status (MMBroadbandBearerHso *self, MMBroadbandBearerHsoConnectionStatus status) { Dial3gppContext *ctx; /* Recover context (if any) and remove both cancellation and timeout (if any)*/ ctx = self->priv->connect_pending; self->priv->connect_pending = NULL; if (self->priv->connect_pending_id) { g_source_remove (self->priv->connect_pending_id); self->priv->connect_pending_id = 0; } if (self->priv->connect_cancellable_id) { g_cancellable_disconnect (ctx->cancellable, self->priv->connect_cancellable_id); self->priv->connect_cancellable_id = 0; } switch (status) { case MM_BROADBAND_BEARER_HSO_CONNECTION_STATUS_UNKNOWN: g_warn_if_reached (); break; case MM_BROADBAND_BEARER_HSO_CONNECTION_STATUS_CONNECTED: if (!ctx) break; g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE); dial_3gpp_context_complete_and_free (ctx); return; case MM_BROADBAND_BEARER_HSO_CONNECTION_STATUS_CONNECTION_FAILED: if (!ctx) break; g_simple_async_result_set_error (ctx->result, MM_CORE_ERROR, MM_CORE_ERROR_FAILED, "Call setup failed"); dial_3gpp_context_complete_and_free (ctx); return; case MM_BROADBAND_BEARER_HSO_CONNECTION_STATUS_DISCONNECTED: if (ctx) { g_simple_async_result_set_error (ctx->result, MM_CORE_ERROR, MM_CORE_ERROR_FAILED, "Call setup failed"); dial_3gpp_context_complete_and_free (ctx); } else { /* Just ensure we mark ourselves as being disconnected... */ mm_bearer_report_disconnection (MM_BEARER (self)); } break; } }
static void custom_init_step (CustomInitContext *ctx) { /* If cancelled, end */ if (g_cancellable_is_cancelled (ctx->cancellable)) { mm_dbg ("(Novatel) no need to keep on running custom init in (%s)", mm_port_get_device (MM_PORT (ctx->port))); g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE); custom_init_context_complete_and_free (ctx); return; } /* If device has a QMI port, don't run $NWDMAT */ if (mm_port_probe_list_has_qmi_port (mm_device_peek_port_probe_list (mm_port_probe_peek_device (ctx->probe)))) { mm_dbg ("(Novatel) no need to run custom init in (%s): device has QMI port", mm_port_get_device (MM_PORT (ctx->port))); g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE); custom_init_context_complete_and_free (ctx); return; } if (ctx->wait_time > 0) { ctx->wait_time--; g_timeout_add_seconds (1, (GSourceFunc)custom_init_wait_cb, ctx); return; } if (ctx->nwdmat_retries > 0) { ctx->nwdmat_retries--; mm_port_serial_at_command (ctx->port, "$NWDMAT=1", 3, FALSE, /* raw */ FALSE, /* allow_cached */ ctx->cancellable, (GAsyncReadyCallback)nwdmat_ready, ctx); return; } /* Finish custom_init */ mm_dbg ("(Novatel) couldn't flip secondary port to AT in (%s): all retries consumed", mm_port_get_device (MM_PORT (ctx->port))); g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE); custom_init_context_complete_and_free (ctx); }
static VALUE rg_set_op_res_gboolean(VALUE self, VALUE op_res) { g_simple_async_result_set_op_res_gboolean(_SELF(self), RVAL2CBOOL(op_res)); return self; }
static void enabling_init_sequence_ready (MMBaseModem *self, GAsyncResult *res, EnablingModemInitContext *ctx) { /* Ignore errors */ mm_base_modem_at_sequence_full_finish (self, res, NULL, NULL); g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE); enabling_modem_init_context_complete_and_free (ctx); }
static void g_simple_async_close_thread_handler(GSimpleAsyncResult *simple, GObject *object, GCancellable *cancellable) { HevSerialPort *self = HEV_SERIAL_PORT(object); HevSerialPortPrivate *priv = HEV_SERIAL_PORT_GET_PRIVATE(self); g_debug("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__); if(-1 == close(priv->fd)) { g_simple_async_result_set_error(simple, G_IO_ERROR, g_io_error_from_errno(errno), "%s", strerror(errno)); g_simple_async_result_set_op_res_gboolean(simple, FALSE); } else { priv->fd = -1; g_simple_async_result_set_op_res_gboolean(simple, TRUE); } }
static void novatel_custom_init_ready (MMPortProbe *probe, GAsyncResult *res, CustomInitContext *ctx) { GError *error = NULL; if (!mm_common_novatel_custom_init_finish (probe, res, &error)) g_simple_async_result_take_error (ctx->result, error); else g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE); custom_init_context_complete_and_free (ctx); }
static void g_simple_async_config_thread_handler(GSimpleAsyncResult *simple, GObject *object, GCancellable *cancellable) { HevSerialPort *self = HEV_SERIAL_PORT(object); HevSerialPortPrivate *priv = HEV_SERIAL_PORT_GET_PRIVATE(self); struct termios *options = NULL; g_debug("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__); options = g_simple_async_result_get_op_res_gpointer(simple); if(-1 == tcflush(priv->fd, TCIFLUSH)) { GError *error = NULL; error = g_error_new(G_IO_ERROR, g_io_error_from_errno(errno), "%s", strerror(errno)); g_simple_async_result_take_error(simple, error); g_simple_async_result_set_op_res_gboolean(simple, FALSE); goto ret; } if(-1 == tcsetattr(priv->fd, TCSANOW, options)) { GError *error = NULL; error = g_error_new(G_IO_ERROR, g_io_error_from_errno(errno), "%s", strerror(errno)); g_simple_async_result_take_error(simple, error); g_simple_async_result_set_op_res_gboolean(simple, FALSE); goto ret; } g_simple_async_result_set_op_res_gboolean(simple, TRUE); ret: g_free(options); }
static void pk_proxy_created_cb (GObject *source, GAsyncResult *result, gpointer user_data) { GtkAppChooserOnlinePk *self = user_data; GDBusProxy *proxy; proxy = g_dbus_proxy_new_finish (result, NULL); if (proxy == NULL) { g_simple_async_result_set_op_res_gboolean (self->priv->init_result, FALSE); } else { g_simple_async_result_set_op_res_gboolean (self->priv->init_result, TRUE); self->priv->proxy = proxy; } g_simple_async_result_complete (self->priv->init_result); g_clear_object (&self->priv->init_result); }
static void modem_time_check_ready (MMBaseModem *self, GAsyncResult *res, GSimpleAsyncResult *simple) { GError *error = NULL; GVariant *result; g_simple_async_result_set_op_res_gboolean (simple, FALSE); result = mm_base_modem_at_sequence_finish (self, res, NULL, &error); if (!error) { MMBroadbandModemSierra *sierra = MM_BROADBAND_MODEM_SIERRA (self); sierra->priv->time_method = g_variant_get_uint32 (result); if (sierra->priv->time_method != TIME_METHOD_UNKNOWN) g_simple_async_result_set_op_res_gboolean (simple, TRUE); } g_clear_error (&error); g_simple_async_result_complete (simple); g_object_unref (simple); }
void mm_port_qmi_open (MMPortQmi *self, gboolean set_data_format, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GFile *file; gchar *fullpath; PortOpenContext *ctx; g_return_if_fail (MM_IS_PORT_QMI (self)); ctx = g_new0 (PortOpenContext, 1); ctx->self = g_object_ref (self); ctx->set_data_format = set_data_format; ctx->result = g_simple_async_result_new (G_OBJECT (self), callback, user_data, mm_port_qmi_open); ctx->cancellable = cancellable ? g_object_ref (cancellable) : NULL; if (self->priv->opening) { g_simple_async_result_set_error (ctx->result, MM_CORE_ERROR, MM_CORE_ERROR_IN_PROGRESS, "QMI device already being opened"); port_open_context_complete_and_free (ctx); return; } if (self->priv->qmi_device) { g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE); port_open_context_complete_and_free (ctx); return; } fullpath = g_strdup_printf ("/dev/%s", mm_port_get_device (MM_PORT (self))); file = g_file_new_for_path (fullpath); self->priv->opening = TRUE; qmi_device_new (file, ctx->cancellable, (GAsyncReadyCallback)qmi_device_new_ready, ctx); g_free (fullpath); g_object_unref (file); }
static void modem_power_down_ready (MMBaseModem *self, GAsyncResult *res, GSimpleAsyncResult *simple) { /* Ignore errors for now; we're not sure if all Sierra CDMA devices support * at!pcstate or 3GPP devices support +CFUN=4. */ mm_base_modem_at_command_finish (MM_BASE_MODEM (self), res, NULL); g_simple_async_result_set_op_res_gboolean (simple, TRUE); g_simple_async_result_complete (simple); g_object_unref (simple); }
static void parent_cleanup_unsolicited_events_ready (MMIfaceModem3gpp *self, GAsyncResult *res, GSimpleAsyncResult *simple) { GError *error = NULL; if (!iface_modem_3gpp_parent->cleanup_unsolicited_events_finish (self, res, &error)) g_simple_async_result_take_error (simple, error); else g_simple_async_result_set_op_res_gboolean (G_SIMPLE_ASYNC_RESULT (res), TRUE); g_simple_async_result_complete (simple); g_object_unref (simple); }
static void init_sequence_ready (MMBroadbandModem *self, GAsyncResult *res, GSimpleAsyncResult *simple) { GError *error = NULL; mm_base_modem_at_sequence_finish (MM_BASE_MODEM (self), res, NULL, &error); if (error) g_simple_async_result_take_error (simple, error); else g_simple_async_result_set_op_res_gboolean (simple, TRUE); g_simple_async_result_complete (simple); g_object_unref (simple); }
static void load_operator_name_or_code (MMIfaceModem3gpp *self, GAsyncReadyCallback callback, gpointer user_data) { GSimpleAsyncResult *result; result = g_simple_async_result_new (G_OBJECT (self), callback, user_data, load_operator_name_or_code); g_simple_async_result_set_op_res_gboolean (result, TRUE); g_simple_async_result_complete_in_idle (result); g_object_unref (result); }
static void set_bands_done (MMIfaceModem *self, GAsyncResult *res, GSimpleAsyncResult *operation_result) { GError *error = NULL; if (!mm_base_modem_at_command_finish (MM_BASE_MODEM (self), res, &error)) g_simple_async_result_take_error (operation_result, error); else g_simple_async_result_set_op_res_gboolean (operation_result, TRUE); g_simple_async_result_complete (operation_result); g_object_unref (operation_result); }
static void own_enable_unsolicited_events_ready (MMBaseModem *self, GAsyncResult *res, GSimpleAsyncResult *simple) { GError *error = NULL; mm_base_modem_at_sequence_full_finish (self, res, NULL, &error); if (error) g_simple_async_result_take_error (simple, error); else g_simple_async_result_set_op_res_gboolean (simple, TRUE); g_simple_async_result_complete (simple); g_object_unref (simple); }
static void pk_vanished_cb (GDBusConnection *conn, const gchar *name, gpointer user_data) { GtkAppChooserOnlinePk *self = user_data; /* just return */ g_simple_async_result_set_op_res_gboolean (self->priv->init_result, FALSE); g_simple_async_result_complete (self->priv->init_result); g_bus_unwatch_name (self->priv->watch_id); g_clear_object (&self->priv->init_result); }
static void disconnect_3gpp_status_complete (MMBaseModem *modem, GAsyncResult *res, DetailedDisconnectContext *ctx) { const gchar *result; GError *error = NULL; result = mm_base_modem_at_command_finish (MM_BASE_MODEM (modem), res, &error); g_simple_async_result_set_op_res_gboolean (ctx->result, FALSE); if (error) { mm_dbg("QMI connection status failed: %s", error->message); g_error_free (error); } result = mm_strip_tag (result, "$NWQMISTATUS:"); if (g_strrstr(result, "QMI State: DISCONNECTED")) g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE); detailed_disconnect_context_complete_and_free (ctx); }