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);
}
