091bf4dbd8
Sometimes SUPL-server based A-GPS is not possible, e.g. if the module doesn't have Internet connectivity. In such cases, the modem may support injecting additional "assistance data" that may be downloaded from the Internet using external means (e.g. WiFi), in order to keep having a quick time to first fix. We now support using this location assistance data, with the following new API elements: * A new mask of supported assistance data types is provided in the SupportedAssistanceData property. * A new list of URLs from where the aassistance data may be downloaded is also provided in a new AssistanceDataServers property. * A new InjectAssistanceData() method is provided, to perform the data injection in the module once it's been downloaded to the host system.
1059 lines
41 KiB
C
1059 lines
41 KiB
C
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*
|
|
* libmm -- Access modem status & information from glib applications
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the
|
|
* Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
* Boston, MA 02110-1301 USA.
|
|
*
|
|
* Copyright (C) 2012 Google, Inc.
|
|
* Copyright (C) 2012 Lanedo GmbH <aleksander@lanedo.com>
|
|
*/
|
|
|
|
#include <gio/gio.h>
|
|
|
|
#include "mm-helpers.h"
|
|
#include "mm-errors-types.h"
|
|
#include "mm-modem-location.h"
|
|
|
|
/**
|
|
* SECTION: mm-modem-location
|
|
* @title: MMModemLocation
|
|
* @short_description: The Location interface
|
|
*
|
|
* The #MMModemLocation is an object providing access to the methods, signals and
|
|
* properties of the Location interface.
|
|
*
|
|
* The Location interface is exposed whenever a modem has location capabilities.
|
|
*/
|
|
|
|
G_DEFINE_TYPE (MMModemLocation, mm_modem_location, MM_GDBUS_TYPE_MODEM_LOCATION_PROXY)
|
|
|
|
/*****************************************************************************/
|
|
|
|
/**
|
|
* mm_modem_location_get_path:
|
|
* @self: A #MMModemLocation.
|
|
*
|
|
* Gets the DBus path of the #MMObject which implements this interface.
|
|
*
|
|
* Returns: (transfer none): The DBus path of the #MMObject object.
|
|
*/
|
|
const gchar *
|
|
mm_modem_location_get_path (MMModemLocation *self)
|
|
{
|
|
g_return_val_if_fail (MM_IS_MODEM_LOCATION (self), NULL);
|
|
|
|
RETURN_NON_EMPTY_CONSTANT_STRING (
|
|
g_dbus_proxy_get_object_path (G_DBUS_PROXY (self)));
|
|
}
|
|
|
|
/**
|
|
* mm_modem_location_dup_path:
|
|
* @self: A #MMModemLocation.
|
|
*
|
|
* Gets a copy of the DBus path of the #MMObject object which implements this interface.
|
|
*
|
|
* Returns: (transfer full): The DBus path of the #MMObject. The returned value should be freed with g_free().
|
|
*/
|
|
gchar *
|
|
mm_modem_location_dup_path (MMModemLocation *self)
|
|
{
|
|
gchar *value;
|
|
|
|
g_return_val_if_fail (MM_IS_MODEM_LOCATION (self), NULL);
|
|
|
|
g_object_get (G_OBJECT (self),
|
|
"g-object-path", &value,
|
|
NULL);
|
|
RETURN_NON_EMPTY_STRING (value);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
/**
|
|
* mm_modem_location_get_capabilities:
|
|
* @self: A #MMModemLocation.
|
|
*
|
|
* Gets a bitmask of the location capabilities supported by this #MMModemLocation.
|
|
*
|
|
* Returns: A #MMModemLocationSource.
|
|
*/
|
|
MMModemLocationSource
|
|
mm_modem_location_get_capabilities (MMModemLocation *self)
|
|
{
|
|
g_return_val_if_fail (MM_IS_MODEM_LOCATION (self), MM_MODEM_LOCATION_SOURCE_NONE);
|
|
|
|
return (MMModemLocationSource) mm_gdbus_modem_location_get_capabilities (MM_GDBUS_MODEM_LOCATION (self));
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
/**
|
|
* mm_modem_location_get_supported_assistance_data:
|
|
* @self: A #MMModemLocation.
|
|
*
|
|
* Gets a bitmask of the supported assistance data types.
|
|
*
|
|
* Returns: A #MMModemLocationAssistanceDataType.
|
|
*/
|
|
MMModemLocationAssistanceDataType
|
|
mm_modem_location_get_supported_assistance_data (MMModemLocation *self)
|
|
{
|
|
g_return_val_if_fail (MM_IS_MODEM_LOCATION (self), MM_MODEM_LOCATION_ASSISTANCE_DATA_TYPE_NONE);
|
|
|
|
return (MMModemLocationAssistanceDataType) mm_gdbus_modem_location_get_supported_assistance_data (MM_GDBUS_MODEM_LOCATION (self));
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
/**
|
|
* mm_modem_location_get_enabled:
|
|
* @self: A #MMModemLocation.
|
|
*
|
|
* Gets a bitmask of the location capabilities which are enabled in this #MMModemLocation.
|
|
*
|
|
* Returns: A #MMModemLocationSource.
|
|
*/
|
|
MMModemLocationSource
|
|
mm_modem_location_get_enabled (MMModemLocation *self)
|
|
{
|
|
g_return_val_if_fail (MM_IS_MODEM_LOCATION (self), FALSE);
|
|
|
|
return (MMModemLocationSource) mm_gdbus_modem_location_get_enabled (MM_GDBUS_MODEM_LOCATION (self));
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
/**
|
|
* mm_modem_location_signals_location:
|
|
* @self: A #MMModemLocation.
|
|
*
|
|
* Gets the status of the location signaling in the #MMModemLocation.
|
|
*
|
|
* Returns: %TRUE if location changes are signaled, %FALSE otherwise..
|
|
*/
|
|
gboolean
|
|
mm_modem_location_signals_location (MMModemLocation *self)
|
|
{
|
|
g_return_val_if_fail (MM_IS_MODEM_LOCATION (self), FALSE);
|
|
|
|
return mm_gdbus_modem_location_get_signals_location (MM_GDBUS_MODEM_LOCATION (self));
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
/**
|
|
* mm_modem_location_setup_finish:
|
|
* @self: A #MMModemLocation.
|
|
* @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_modem_location_setup().
|
|
* @error: Return location for error or %NULL.
|
|
*
|
|
* Finishes an operation started with mm_modem_location_setup().
|
|
*
|
|
* Returns: %TRUE if the setup was successful, %FALSE if @error is set.
|
|
*/
|
|
gboolean
|
|
mm_modem_location_setup_finish (MMModemLocation *self,
|
|
GAsyncResult *res,
|
|
GError **error)
|
|
{
|
|
g_return_val_if_fail (MM_IS_MODEM_LOCATION (self), FALSE);
|
|
|
|
return mm_gdbus_modem_location_call_setup_finish (MM_GDBUS_MODEM_LOCATION (self), res, error);
|
|
}
|
|
|
|
/**
|
|
* mm_modem_location_setup:
|
|
* @self: A #MMModemLocation.
|
|
* @sources: Bitmask of #MMModemLocationSource values specifying which locations should get enabled.
|
|
* @signal_location: Flag to enable or disable location signaling.
|
|
* @cancellable: (allow-none): A #GCancellable or %NULL.
|
|
* @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
|
|
* @user_data: User data to pass to @callback.
|
|
*
|
|
* Asynchronously configures the location sources to use when gathering location
|
|
* information. Also enable or disable location information gathering.
|
|
*
|
|
* When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
|
|
* You can then call mm_modem_location_setup_finish() to get the result of the operation.
|
|
*
|
|
* See mm_modem_location_setup_sync() for the synchronous, blocking version of this method.
|
|
*/
|
|
void
|
|
mm_modem_location_setup (MMModemLocation *self,
|
|
MMModemLocationSource sources,
|
|
gboolean signal_location,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
g_return_if_fail (MM_IS_MODEM_LOCATION (self));
|
|
|
|
mm_gdbus_modem_location_call_setup (MM_GDBUS_MODEM_LOCATION (self),
|
|
sources,
|
|
signal_location,
|
|
cancellable,
|
|
callback,
|
|
user_data);
|
|
}
|
|
|
|
/**
|
|
* mm_modem_location_setup_sync:
|
|
* @self: A #MMModemLocation.
|
|
* @sources: Bitmask of #MMModemLocationSource values specifying which locations should get enabled.
|
|
* @signal_location: Flag to enable or disable location signaling.
|
|
* @cancellable: (allow-none): A #GCancellable or %NULL.
|
|
* @error: Return location for error or %NULL.
|
|
*
|
|
* Synchronously configures the location sources to use when gathering location
|
|
* information. Also enable or disable location information gathering.
|
|
*
|
|
* The calling thread is blocked until a reply is received. See mm_modem_location_setup()
|
|
* for the asynchronous version of this method.
|
|
*
|
|
* Returns: %TRUE if the setup was successful, %FALSE if @error is set.
|
|
*/
|
|
gboolean
|
|
mm_modem_location_setup_sync (MMModemLocation *self,
|
|
MMModemLocationSource sources,
|
|
gboolean signal_location,
|
|
GCancellable *cancellable,
|
|
GError **error)
|
|
{
|
|
g_return_val_if_fail (MM_IS_MODEM_LOCATION (self), FALSE);
|
|
|
|
return mm_gdbus_modem_location_call_setup_sync (MM_GDBUS_MODEM_LOCATION (self),
|
|
sources,
|
|
signal_location,
|
|
cancellable,
|
|
error);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
/**
|
|
* mm_modem_location_set_supl_server_finish:
|
|
* @self: A #MMModemLocation.
|
|
* @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_modem_location_set_supl_server().
|
|
* @error: Return location for error or %NULL.
|
|
*
|
|
* Finishes an operation started with mm_modem_location_set_supl_server().
|
|
*
|
|
* Returns: %TRUE if setting the SUPL server was successful, %FALSE if @error is set.
|
|
*/
|
|
gboolean
|
|
mm_modem_location_set_supl_server_finish (MMModemLocation *self,
|
|
GAsyncResult *res,
|
|
GError **error)
|
|
{
|
|
g_return_val_if_fail (MM_IS_MODEM_LOCATION (self), FALSE);
|
|
|
|
return mm_gdbus_modem_location_call_set_supl_server_finish (MM_GDBUS_MODEM_LOCATION (self), res, error);
|
|
}
|
|
|
|
/**
|
|
* mm_modem_location_set_supl_server:
|
|
* @self: A #MMModemLocation.
|
|
* @supl: The SUPL server address, given as IP:PORT or with a full URL.
|
|
* @cancellable: (allow-none): A #GCancellable or %NULL.
|
|
* @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
|
|
* @user_data: User data to pass to @callback.
|
|
*
|
|
* Asynchronously configures the address of the SUPL server for A-GPS operation.
|
|
*
|
|
* When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
|
|
* You can then call mm_modem_location_set_supl_server_finish() to get the result of the operation.
|
|
*
|
|
* See mm_modem_location_set_supl_server_sync() for the synchronous, blocking version of this method.
|
|
*/
|
|
void
|
|
mm_modem_location_set_supl_server (MMModemLocation *self,
|
|
const gchar *supl,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
g_return_if_fail (MM_IS_MODEM_LOCATION (self));
|
|
|
|
mm_gdbus_modem_location_call_set_supl_server (MM_GDBUS_MODEM_LOCATION (self),
|
|
supl,
|
|
cancellable,
|
|
callback,
|
|
user_data);
|
|
}
|
|
|
|
/**
|
|
* mm_modem_location_set_supl_server_sync:
|
|
* @self: A #MMModemLocation.
|
|
* @supl: The SUPL server address, given as IP:PORT or with a full URL.
|
|
* @cancellable: (allow-none): A #GCancellable or %NULL.
|
|
* @error: Return location for error or %NULL.
|
|
*
|
|
* Synchronously configures the address of the SUPL server for A-GPS operation.
|
|
*
|
|
* The calling thread is blocked until a reply is received. See mm_modem_location_set_supl_server()
|
|
* for the asynchronous version of this method.
|
|
*
|
|
* Returns: %TRUE if setting the SUPL server was successful, %FALSE if @error is set.
|
|
*/
|
|
gboolean
|
|
mm_modem_location_set_supl_server_sync (MMModemLocation *self,
|
|
const gchar *supl,
|
|
GCancellable *cancellable,
|
|
GError **error)
|
|
{
|
|
g_return_val_if_fail (MM_IS_MODEM_LOCATION (self), FALSE);
|
|
|
|
return mm_gdbus_modem_location_call_set_supl_server_sync (MM_GDBUS_MODEM_LOCATION (self),
|
|
supl,
|
|
cancellable,
|
|
error);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
/**
|
|
* mm_modem_location_inject_assistance_data_finish:
|
|
* @self: A #MMModemLocation.
|
|
* @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_modem_location_inject_assistance_data().
|
|
* @error: Return location for error or %NULL.
|
|
*
|
|
* Finishes an operation started with mm_modem_location_inject_assistance_data().
|
|
*
|
|
* Returns: %TRUE if the injection was successful, %FALSE if @error is set.
|
|
*/
|
|
gboolean
|
|
mm_modem_location_inject_assistance_data_finish (MMModemLocation *self,
|
|
GAsyncResult *res,
|
|
GError **error)
|
|
{
|
|
g_return_val_if_fail (MM_IS_MODEM_LOCATION (self), FALSE);
|
|
|
|
return mm_gdbus_modem_location_call_inject_assistance_data_finish (MM_GDBUS_MODEM_LOCATION (self), res, error);
|
|
}
|
|
|
|
/**
|
|
* mm_modem_location_inject_assistance_data:
|
|
* @self: A #MMModemLocation.
|
|
* @data: (array length=data_size): Data to inject.
|
|
* @data_size: size of @data.
|
|
* @cancellable: (allow-none): A #GCancellable or %NULL.
|
|
* @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
|
|
* @user_data: User data to pass to @callback.
|
|
*
|
|
* Aynchronously injects assistance data to the GNSS module.
|
|
*
|
|
* When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
|
|
* You can then call mm_modem_location_inject_assistance_data_finish() to get the result of the operation.
|
|
*
|
|
* See mm_modem_location_inject_assistance_data_sync() for the synchronous, blocking version of this method.
|
|
*/
|
|
void
|
|
mm_modem_location_inject_assistance_data (MMModemLocation *self,
|
|
const guint8 *data,
|
|
gsize data_size,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
g_return_if_fail (MM_IS_MODEM_LOCATION (self));
|
|
|
|
mm_gdbus_modem_location_call_inject_assistance_data (MM_GDBUS_MODEM_LOCATION (self),
|
|
g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE, data, data_size, sizeof (guint8)),
|
|
cancellable,
|
|
callback,
|
|
user_data);
|
|
}
|
|
|
|
/**
|
|
* mm_modem_location_inject_assistance_data_sync:
|
|
* @self: A #MMModemLocation.
|
|
* @data: (array length=data_size): Data to inject.
|
|
* @data_size: size of @data.
|
|
* @cancellable: (allow-none): A #GCancellable or %NULL.
|
|
* @error: Return location for error or %NULL.
|
|
*
|
|
* Synchronously injects assistance data to the GNSS module.
|
|
*
|
|
* The calling thread is blocked until a reply is received. See mm_modem_location_inject_assistance_data()
|
|
* for the asynchronous version of this method.
|
|
*
|
|
* Returns: %TRUE if the injection was successful, %FALSE if @error is set.
|
|
*/
|
|
gboolean
|
|
mm_modem_location_inject_assistance_data_sync (MMModemLocation *self,
|
|
const guint8 *data,
|
|
gsize data_size,
|
|
GCancellable *cancellable,
|
|
GError **error)
|
|
{
|
|
g_return_val_if_fail (MM_IS_MODEM_LOCATION (self), FALSE);
|
|
|
|
return mm_gdbus_modem_location_call_inject_assistance_data_sync (MM_GDBUS_MODEM_LOCATION (self),
|
|
g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE, data, data_size, sizeof (guint8)),
|
|
cancellable,
|
|
error);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
/**
|
|
* mm_modem_location_set_gps_refresh_rate_finish:
|
|
* @self: A #MMModemLocation.
|
|
* @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_modem_location_set_gps_refresh_rate().
|
|
* @error: Return location for error or %NULL.
|
|
*
|
|
* Finishes an operation started with mm_modem_location_set_gps_refresh_rate().
|
|
*
|
|
* Returns: %TRUE if setting the GPS refresh rate was successful, %FALSE if @error is set.
|
|
*/
|
|
gboolean
|
|
mm_modem_location_set_gps_refresh_rate_finish (MMModemLocation *self,
|
|
GAsyncResult *res,
|
|
GError **error)
|
|
{
|
|
g_return_val_if_fail (MM_IS_MODEM_LOCATION (self), FALSE);
|
|
|
|
return mm_gdbus_modem_location_call_set_gps_refresh_rate_finish (MM_GDBUS_MODEM_LOCATION (self), res, error);
|
|
}
|
|
|
|
/**
|
|
* mm_modem_location_set_gps_refresh_rate:
|
|
* @self: A #MMModemLocation.
|
|
* @rate: The GPS refresh rate, in seconds.
|
|
* @cancellable: (allow-none): A #GCancellable or %NULL.
|
|
* @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
|
|
* @user_data: User data to pass to @callback.
|
|
*
|
|
* Asynchronously configures the GPS refresh rate.
|
|
|
|
* If a 0 rate is used, the GPS location updates will be immediately propagated to the interface.
|
|
*
|
|
* When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
|
|
* You can then call mm_modem_location_set_gps_refresh_rate_finish() to get the result of the operation.
|
|
*
|
|
* See mm_modem_location_set_gps_refresh_rate_sync() for the synchronous, blocking version of this method.
|
|
*/
|
|
void
|
|
mm_modem_location_set_gps_refresh_rate (MMModemLocation *self,
|
|
guint rate,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
g_return_if_fail (MM_IS_MODEM_LOCATION (self));
|
|
|
|
mm_gdbus_modem_location_call_set_gps_refresh_rate (MM_GDBUS_MODEM_LOCATION (self),
|
|
rate,
|
|
cancellable,
|
|
callback,
|
|
user_data);
|
|
}
|
|
|
|
/**
|
|
* mm_modem_location_set_gps_refresh_rate_sync:
|
|
* @self: A #MMModemLocation.
|
|
* @rate: The GPS refresh rate, in seconds.
|
|
* @cancellable: (allow-none): A #GCancellable or %NULL.
|
|
* @error: Return location for error or %NULL.
|
|
*
|
|
* Synchronously configures the GPS refresh rate.
|
|
*
|
|
* If a 0 rate is used, the GPS location updates will be immediately propagated to the interface.
|
|
*
|
|
* The calling thread is blocked until a reply is received. See mm_modem_location_set_gps_refresh_rate()
|
|
* for the asynchronous version of this method.
|
|
*
|
|
* Returns: %TRUE if setting the refresh rate was successful, %FALSE if @error is set.
|
|
*/
|
|
gboolean
|
|
mm_modem_location_set_gps_refresh_rate_sync (MMModemLocation *self,
|
|
guint rate,
|
|
GCancellable *cancellable,
|
|
GError **error)
|
|
{
|
|
g_return_val_if_fail (MM_IS_MODEM_LOCATION (self), FALSE);
|
|
|
|
return mm_gdbus_modem_location_call_set_gps_refresh_rate_sync (MM_GDBUS_MODEM_LOCATION (self),
|
|
rate,
|
|
cancellable,
|
|
error);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
static gboolean
|
|
build_locations (GVariant *dictionary,
|
|
MMLocation3gpp **location_3gpp,
|
|
MMLocationGpsNmea **location_gps_nmea,
|
|
MMLocationGpsRaw **location_gps_raw,
|
|
MMLocationCdmaBs **location_cdma_bs,
|
|
GError **error)
|
|
{
|
|
GError *inner_error = NULL;
|
|
GVariant *value;
|
|
guint source;
|
|
GVariantIter iter;
|
|
|
|
if (!dictionary)
|
|
/* No location provided. Not actually an error. */
|
|
return TRUE;
|
|
|
|
g_variant_iter_init (&iter, dictionary);
|
|
while (!inner_error &&
|
|
g_variant_iter_next (&iter, "{uv}", &source, &value)) {
|
|
switch (source) {
|
|
case MM_MODEM_LOCATION_SOURCE_3GPP_LAC_CI:
|
|
if (location_3gpp)
|
|
*location_3gpp = mm_location_3gpp_new_from_string_variant (value, &inner_error);
|
|
break;
|
|
case MM_MODEM_LOCATION_SOURCE_GPS_NMEA:
|
|
if (location_gps_nmea)
|
|
*location_gps_nmea = mm_location_gps_nmea_new_from_string_variant (value, &inner_error);
|
|
break;
|
|
case MM_MODEM_LOCATION_SOURCE_GPS_RAW:
|
|
if (location_gps_raw)
|
|
*location_gps_raw = mm_location_gps_raw_new_from_dictionary (value, &inner_error);
|
|
break;
|
|
case MM_MODEM_LOCATION_SOURCE_CDMA_BS:
|
|
if (location_cdma_bs)
|
|
*location_cdma_bs = mm_location_cdma_bs_new_from_dictionary (value, &inner_error);
|
|
break;
|
|
default:
|
|
g_warn_if_reached ();
|
|
break;
|
|
}
|
|
|
|
g_variant_unref (value);
|
|
}
|
|
|
|
g_variant_unref (dictionary);
|
|
|
|
if (inner_error) {
|
|
g_propagate_error (error, inner_error);
|
|
g_prefix_error (error,
|
|
"Couldn't build locations result: ");
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* mm_modem_location_get_full_finish:
|
|
* @self: A #MMModemLocation.
|
|
* @location_3gpp: (out) (allow-none) (transfer full): Return location for a #MMLocation3gpp if 3GPP location is requested, or #NULL if not required. The returned value should be freed with g_object_unref().
|
|
* @location_gps_nmea: (out) (allow-none) (transfer full): Return location for a #MMLocationGpsNmea if GPS NMEA location is requested, or #NULL if not required. The returned value should be freed with g_object_unref().
|
|
* @location_gps_raw: (out) (allow-none) (transfer full): Return location for a #MMLocationGpsRaw if GPS raw location is requested, or #NULL if not required. The returned value should be freed with g_object_unref().
|
|
* @location_cdma_bs: (out) (allow-none) (transfer full): Return location for a #MMLocationCdmaBs if CDMA Base Station location is requested, or #NULL if not required. The returned value should be freed with g_object_unref().
|
|
* @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_modem_location_get_full().
|
|
* @error: Return location for error or %NULL.
|
|
*
|
|
* Finishes an operation started with mm_modem_location_get_full().
|
|
*
|
|
* Returns: %TRUE if the retrieval was successful, %FALSE if @error is set.
|
|
*/
|
|
gboolean
|
|
mm_modem_location_get_full_finish (MMModemLocation *self,
|
|
GAsyncResult *res,
|
|
MMLocation3gpp **location_3gpp,
|
|
MMLocationGpsNmea **location_gps_nmea,
|
|
MMLocationGpsRaw **location_gps_raw,
|
|
MMLocationCdmaBs **location_cdma_bs,
|
|
GError **error)
|
|
{
|
|
GVariant *dictionary = NULL;
|
|
|
|
g_return_val_if_fail (MM_IS_MODEM_LOCATION (self), FALSE);
|
|
|
|
if (!mm_gdbus_modem_location_call_get_location_finish (MM_GDBUS_MODEM_LOCATION (self), &dictionary, res, error))
|
|
return FALSE;
|
|
|
|
return build_locations (dictionary, location_3gpp, location_gps_nmea, location_gps_raw, location_cdma_bs, error);
|
|
}
|
|
|
|
/**
|
|
* mm_modem_location_get_full:
|
|
* @self: A #MMModemLocation.
|
|
* @cancellable: (allow-none): A #GCancellable or %NULL.
|
|
* @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
|
|
* @user_data: User data to pass to @callback.
|
|
*
|
|
* Asynchronously gets the current location information.
|
|
*
|
|
* When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
|
|
* You can then call mm_modem_location_get_full_finish() to get the result of the operation.
|
|
*
|
|
* See mm_modem_location_get_full_sync() for the synchronous, blocking version of this method.
|
|
*/
|
|
void
|
|
mm_modem_location_get_full (MMModemLocation *self,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
g_return_if_fail (MM_IS_MODEM_LOCATION (self));
|
|
|
|
mm_gdbus_modem_location_call_get_location (MM_GDBUS_MODEM_LOCATION (self),
|
|
cancellable,
|
|
callback,
|
|
user_data);
|
|
}
|
|
|
|
/**
|
|
* mm_modem_location_get_full_sync:
|
|
* @self: A #MMModemLocation.
|
|
* @location_3gpp: (out) (allow-none) (transfer full): Return location for a #MMLocation3gpp if 3GPP location is requested, or #NULL if not required. The returned value should be freed with g_object_unref().
|
|
* @location_gps_nmea: (out) (allow-none) (transfer full): Return location for a #MMLocationGpsNmea if GPS NMEA location is requested, or #NULL if not required. The returned value should be freed with g_object_unref().
|
|
* @location_gps_raw: (out) (allow-none) (transfer full): Return location for a #MMLocationGpsRaw if GPS raw location is requested, or #NULL if not required. The returned value should be freed with g_object_unref().
|
|
* @location_cdma_bs: (out) (allow-none) (transfer full): Return location for a #MMLocationCdmaBs if CDMA Base Station location is requested, or #NULL if not required. The returned value should be freed with g_object_unref().
|
|
* @cancellable: (allow-none): A #GCancellable or %NULL.
|
|
* @error: Return location for error or %NULL.
|
|
*
|
|
* Synchronously gets the current location information.
|
|
*
|
|
* The calling thread is blocked until a reply is received. See mm_modem_location_get_full()
|
|
* for the asynchronous version of this method.
|
|
*
|
|
* Returns: %TRUE if the setup was successful, %FALSE if @error is set.
|
|
*/
|
|
gboolean
|
|
mm_modem_location_get_full_sync (MMModemLocation *self,
|
|
MMLocation3gpp **location_3gpp,
|
|
MMLocationGpsNmea **location_gps_nmea,
|
|
MMLocationGpsRaw **location_gps_raw,
|
|
MMLocationCdmaBs **location_cdma_bs,
|
|
GCancellable *cancellable,
|
|
GError **error)
|
|
{
|
|
GVariant *dictionary = NULL;
|
|
|
|
g_return_val_if_fail (MM_IS_MODEM_LOCATION (self), FALSE);
|
|
|
|
if (!mm_gdbus_modem_location_call_get_location_sync (MM_GDBUS_MODEM_LOCATION (self), &dictionary, cancellable, error))
|
|
return FALSE;
|
|
|
|
return build_locations (dictionary, location_3gpp, location_gps_nmea, location_gps_raw, location_cdma_bs, error);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
/**
|
|
* mm_modem_location_get_3gpp_finish:
|
|
* @self: A #MMModemLocation.
|
|
* @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_modem_location_get_3gpp().
|
|
* @error: Return location for error or %NULL.
|
|
*
|
|
* Finishes an operation started with mm_modem_location_get_3gpp().
|
|
*
|
|
* Returns: (transfer full): A #MMLocation3gpp, or #NULL if not available. The returned value should be freed with g_object_unref().
|
|
*/
|
|
MMLocation3gpp *
|
|
mm_modem_location_get_3gpp_finish (MMModemLocation *self,
|
|
GAsyncResult *res,
|
|
GError **error)
|
|
{
|
|
MMLocation3gpp *location = NULL;
|
|
|
|
mm_modem_location_get_full_finish (self, res, &location, NULL, NULL, NULL, error);
|
|
|
|
return location;
|
|
}
|
|
|
|
/**
|
|
* mm_modem_location_get_3gpp:
|
|
* @self: A #MMModemLocation.
|
|
* @cancellable: (allow-none): A #GCancellable or %NULL.
|
|
* @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
|
|
* @user_data: User data to pass to @callback.
|
|
*
|
|
* Asynchronously gets the current 3GPP location information.
|
|
*
|
|
* When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
|
|
* You can then call mm_modem_location_get_3gpp_finish() to get the result of the operation.
|
|
*
|
|
* See mm_modem_location_get_3gpp_sync() for the synchronous, blocking version of this method.
|
|
*/
|
|
void
|
|
mm_modem_location_get_3gpp (MMModemLocation *self,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
mm_modem_location_get_full (self, cancellable, callback, user_data);
|
|
}
|
|
|
|
/**
|
|
* mm_modem_location_get_3gpp_sync:
|
|
* @self: A #MMModemLocation.
|
|
* @cancellable: (allow-none): A #GCancellable or %NULL.
|
|
* @error: Return location for error or %NULL.
|
|
*
|
|
* Synchronously gets the current 3GPP location information.
|
|
*
|
|
* The calling thread is blocked until a reply is received. See mm_modem_location_get_3gpp()
|
|
* for the asynchronous version of this method.
|
|
*
|
|
* Returns: (transfer full): A #MMLocation3gpp, or #NULL if not available. The returned value should be freed with g_object_unref().
|
|
*/
|
|
MMLocation3gpp *
|
|
mm_modem_location_get_3gpp_sync (MMModemLocation *self,
|
|
GCancellable *cancellable,
|
|
GError **error)
|
|
{
|
|
MMLocation3gpp *location = NULL;
|
|
|
|
mm_modem_location_get_full_sync (self, &location, NULL, NULL, NULL, cancellable, error);
|
|
|
|
return location;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
/**
|
|
* mm_modem_location_get_gps_nmea_finish:
|
|
* @self: A #MMModemLocation.
|
|
* @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_modem_location_get_gps_nmea().
|
|
* @error: Return location for error or %NULL.
|
|
*
|
|
* Finishes an operation started with mm_modem_location_get_gps_nmea().
|
|
*
|
|
* Returns: (transfer full): A #MMLocationGpsNmea, or #NULL if not available. The returned value should be freed with g_object_unref().
|
|
*/
|
|
MMLocationGpsNmea *
|
|
mm_modem_location_get_gps_nmea_finish (MMModemLocation *self,
|
|
GAsyncResult *res,
|
|
GError **error)
|
|
{
|
|
MMLocationGpsNmea *location = NULL;
|
|
|
|
mm_modem_location_get_full_finish (self, res, NULL, &location, NULL, NULL, error);
|
|
|
|
return location;
|
|
}
|
|
|
|
/**
|
|
* mm_modem_location_get_gps_nmea:
|
|
* @self: A #MMModemLocation.
|
|
* @cancellable: (allow-none): A #GCancellable or %NULL.
|
|
* @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
|
|
* @user_data: User data to pass to @callback.
|
|
*
|
|
* Asynchronously gets the current GPS NMEA location information.
|
|
*
|
|
* When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
|
|
* You can then call mm_modem_location_get_gps_nmea_finish() to get the result of the operation.
|
|
*
|
|
* See mm_modem_location_get_gps_nmea_sync() for the synchronous, blocking version of this method.
|
|
*/
|
|
void
|
|
mm_modem_location_get_gps_nmea (MMModemLocation *self,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
mm_modem_location_get_full (self, cancellable, callback, user_data);
|
|
}
|
|
|
|
/**
|
|
* mm_modem_location_get_gps_nmea_sync:
|
|
* @self: A #MMModemLocation.
|
|
* @cancellable: (allow-none): A #GCancellable or %NULL.
|
|
* @error: Return location for error or %NULL.
|
|
*
|
|
* Synchronously gets the current GPS NMEA location information.
|
|
*
|
|
* The calling thread is blocked until a reply is received. See mm_modem_location_get_gps_nmea()
|
|
* for the asynchronous version of this method.
|
|
*
|
|
* Returns: (transfer full): A #MMLocationGpsNmea, or #NULL if not available. The returned value should be freed with g_object_unref().
|
|
*/
|
|
MMLocationGpsNmea *
|
|
mm_modem_location_get_gps_nmea_sync (MMModemLocation *self,
|
|
GCancellable *cancellable,
|
|
GError **error)
|
|
{
|
|
MMLocationGpsNmea *location = NULL;
|
|
|
|
mm_modem_location_get_full_sync (self, NULL, &location, NULL, NULL, cancellable, error);
|
|
|
|
return location;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
/**
|
|
* mm_modem_location_get_gps_raw_finish:
|
|
* @self: A #MMModemLocation.
|
|
* @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_modem_location_get_gps_raw().
|
|
* @error: Return location for error or %NULL.
|
|
*
|
|
* Finishes an operation started with mm_modem_location_get_gps_raw().
|
|
*
|
|
* Returns: (transfer full): A #MMLocationGpsRaw, or #NULL if not available. The returned value should be freed with g_object_unref().
|
|
*/
|
|
MMLocationGpsRaw *
|
|
mm_modem_location_get_gps_raw_finish (MMModemLocation *self,
|
|
GAsyncResult *res,
|
|
GError **error)
|
|
{
|
|
MMLocationGpsRaw *location = NULL;
|
|
|
|
mm_modem_location_get_full_finish (self, res, NULL, NULL, &location, NULL, error);
|
|
|
|
return location;
|
|
}
|
|
|
|
/**
|
|
* mm_modem_location_get_gps_raw:
|
|
* @self: A #MMModemLocation.
|
|
* @cancellable: (allow-none): A #GCancellable or %NULL.
|
|
* @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
|
|
* @user_data: User data to pass to @callback.
|
|
*
|
|
* Asynchronously gets the current GPS raw location information.
|
|
*
|
|
* When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
|
|
* You can then call mm_modem_location_get_gps_raw_finish() to get the result of the operation.
|
|
*
|
|
* See mm_modem_location_get_gps_raw_sync() for the synchronous, blocking version of this method.
|
|
*/
|
|
void
|
|
mm_modem_location_get_gps_raw (MMModemLocation *self,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
mm_modem_location_get_full (self, cancellable, callback, user_data);
|
|
}
|
|
|
|
/**
|
|
* mm_modem_location_get_gps_raw_sync:
|
|
* @self: A #MMModemLocation.
|
|
* @cancellable: (allow-none): A #GCancellable or %NULL.
|
|
* @error: Return location for error or %NULL.
|
|
*
|
|
* Synchronously gets the current GPS raw location information.
|
|
*
|
|
* The calling thread is blocked until a reply is received. See mm_modem_location_get_gps_raw()
|
|
* for the asynchronous version of this method.
|
|
*
|
|
* Returns: (transfer full): A #MMLocationGpsRaw, or #NULL if not available. The returned value should be freed with g_object_unref().
|
|
*/
|
|
MMLocationGpsRaw *
|
|
mm_modem_location_get_gps_raw_sync (MMModemLocation *self,
|
|
GCancellable *cancellable,
|
|
GError **error)
|
|
{
|
|
MMLocationGpsRaw *location = NULL;
|
|
|
|
mm_modem_location_get_full_sync (self, NULL, NULL, &location, NULL, cancellable, error);
|
|
|
|
return location;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
/**
|
|
* mm_modem_location_get_cdma_bs_finish:
|
|
* @self: A #MMModemLocation.
|
|
* @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to mm_modem_location_get_cdma_bs().
|
|
* @error: Return location for error or %NULL.
|
|
*
|
|
* Finishes an operation started with mm_modem_location_get_cdma_bs().
|
|
*
|
|
* Returns: (transfer full): A #MMLocationCdmaBs, or #NULL if not available. The returned value should be freed with g_object_unref().
|
|
*/
|
|
MMLocationCdmaBs *
|
|
mm_modem_location_get_cdma_bs_finish (MMModemLocation *self,
|
|
GAsyncResult *res,
|
|
GError **error)
|
|
{
|
|
MMLocationCdmaBs *location = NULL;
|
|
|
|
mm_modem_location_get_full_finish (self, res, NULL, NULL, NULL, &location, error);
|
|
|
|
return location;
|
|
}
|
|
|
|
/**
|
|
* mm_modem_location_get_cdma_bs:
|
|
* @self: A #MMModemLocation.
|
|
* @cancellable: (allow-none): A #GCancellable or %NULL.
|
|
* @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
|
|
* @user_data: User data to pass to @callback.
|
|
*
|
|
* Asynchronously gets the current CDMA base station location information.
|
|
*
|
|
* When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
|
|
* You can then call mm_modem_location_get_cdma_bs_finish() to get the result of the operation.
|
|
*
|
|
* See mm_modem_location_get_cdma_bs_sync() for the synchronous, blocking version of this method.
|
|
*/
|
|
void
|
|
mm_modem_location_get_cdma_bs (MMModemLocation *self,
|
|
GCancellable *cancellable,
|
|
GAsyncReadyCallback callback,
|
|
gpointer user_data)
|
|
{
|
|
mm_modem_location_get_full (self, cancellable, callback, user_data);
|
|
}
|
|
|
|
/**
|
|
* mm_modem_location_get_cdma_bs_sync:
|
|
* @self: A #MMModemLocation.
|
|
* @cancellable: (allow-none): A #GCancellable or %NULL.
|
|
* @error: Return location for error or %NULL.
|
|
*
|
|
* Synchronously gets the current CDMA base station location information.
|
|
*
|
|
* The calling thread is blocked until a reply is received. See mm_modem_location_get_cdma_bs()
|
|
* for the asynchronous version of this method.
|
|
*
|
|
* Returns: (transfer full): A #MMLocationCdmaBs, or #NULL if not available. The returned value should be freed with g_object_unref().
|
|
*/
|
|
MMLocationCdmaBs *
|
|
mm_modem_location_get_cdma_bs_sync (MMModemLocation *self,
|
|
GCancellable *cancellable,
|
|
GError **error)
|
|
{
|
|
MMLocationCdmaBs *location = NULL;
|
|
|
|
mm_modem_location_get_full_sync (self, NULL, NULL, NULL, &location, cancellable, error);
|
|
|
|
return location;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
/**
|
|
* mm_modem_location_get_supl_server:
|
|
* @self: A #MMModemLocation.
|
|
*
|
|
* Gets the address of the SUPL server.
|
|
*
|
|
* <warning>The returned value is only valid until the property changes so
|
|
* it is only safe to use this function on the thread where
|
|
* @self was constructed. Use mm_modem_location_dup_supl_server() if on another
|
|
* thread.</warning>
|
|
*
|
|
* Returns: (transfer none): The SUPL server address, or %NULL if none available. Do not free the returned value, it belongs to @self.
|
|
*/
|
|
const gchar *
|
|
mm_modem_location_get_supl_server (MMModemLocation *self)
|
|
{
|
|
g_return_val_if_fail (MM_IS_MODEM_LOCATION (self), NULL);
|
|
|
|
RETURN_NON_EMPTY_CONSTANT_STRING (
|
|
mm_gdbus_modem_location_get_supl_server (MM_GDBUS_MODEM_LOCATION (self)));
|
|
}
|
|
|
|
/**
|
|
* mm_modem_location_dup_supl_server:
|
|
* @self: A #MMModemLocation.
|
|
*
|
|
* Gets the address of the SUPL server.
|
|
*
|
|
* Returns: (transfer full): The SUPL server address, or %NULL if none available. The returned value should be freed with g_free().
|
|
*/
|
|
gchar *
|
|
mm_modem_location_dup_supl_server (MMModemLocation *self)
|
|
{
|
|
g_return_val_if_fail (MM_IS_MODEM_LOCATION (self), NULL);
|
|
|
|
RETURN_NON_EMPTY_STRING (
|
|
mm_gdbus_modem_location_dup_supl_server (MM_GDBUS_MODEM_LOCATION (self)));
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
/**
|
|
* mm_modem_location_get_assistance_data_servers:
|
|
* @self: A #MMModemLocation.
|
|
*
|
|
* Gets the list of assistance data servers.
|
|
*
|
|
* <warning>The returned value is only valid until the property changes so
|
|
* it is only safe to use this function on the thread where
|
|
* @self was constructed. Use mm_modem_location_dup_assistance_data_servers() if on another
|
|
* thread.</warning>
|
|
*
|
|
* Returns: (transfer none): a %NULL-terminated array of server addresses, or %NULL if none available. Do not free the returned value, it belongs to @self.
|
|
*/
|
|
const gchar **
|
|
mm_modem_location_get_assistance_data_servers (MMModemLocation *self)
|
|
{
|
|
const gchar **tmp;
|
|
|
|
g_return_val_if_fail (MM_IS_MODEM_LOCATION (self), NULL);
|
|
|
|
tmp = (const gchar **) mm_gdbus_modem_location_get_assistance_data_servers (MM_GDBUS_MODEM_LOCATION (self));
|
|
|
|
return ((tmp && tmp[0]) ? tmp : NULL);
|
|
}
|
|
|
|
/**
|
|
* mm_modem_location_dup_assistance_data_servers:
|
|
* @self: A #MMModemLocation.
|
|
*
|
|
* Gets the list of assistance data servers.
|
|
*
|
|
* Returns: (transfer full): a %NULL-terminated array of server addresses, or %NULL if none available. The returned value should be freed with g_strfreev().
|
|
*/
|
|
gchar **
|
|
mm_modem_location_dup_assistance_data_servers (MMModemLocation *self)
|
|
{
|
|
gchar **tmp;
|
|
|
|
g_return_val_if_fail (MM_IS_MODEM_LOCATION (self), NULL);
|
|
|
|
tmp = mm_gdbus_modem_location_dup_assistance_data_servers (MM_GDBUS_MODEM_LOCATION (self));
|
|
if (tmp && tmp[0])
|
|
return tmp;
|
|
|
|
g_strfreev (tmp);
|
|
return NULL;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
/**
|
|
* mm_modem_location_get_gps_refresh_rate:
|
|
* @self: A #MMModemLocation.
|
|
*
|
|
* Gets the GPS refresh rate, in seconds.
|
|
*
|
|
* Returns: The GPS refresh rate, or 0 if no fixed rate is used.
|
|
*/
|
|
guint
|
|
mm_modem_location_get_gps_refresh_rate (MMModemLocation *self)
|
|
{
|
|
g_return_val_if_fail (MM_IS_MODEM_LOCATION (self), 0);
|
|
|
|
return mm_gdbus_modem_location_get_gps_refresh_rate (MM_GDBUS_MODEM_LOCATION (self));
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
|
|
static void
|
|
mm_modem_location_init (MMModemLocation *self)
|
|
{
|
|
}
|
|
|
|
static void
|
|
mm_modem_location_class_init (MMModemLocationClass *modem_class)
|
|
{
|
|
}
|