#include "config.h"
-/* Needed for trunc */
-#define _ISOC9X_SOURCE 1
-#define _ISOC99_SOURCE 1
-#include <math.h>
#include <string.h>
#include <time.h>
#include <glib/gi18n.h>
+#include <telepathy-glib/account-manager.h>
#include <telepathy-glib/util.h>
#include <geoclue/geoclue-master.h>
#include "empathy-location-manager.h"
#include "empathy-conf.h"
-#include "libempathy/empathy-account-manager.h"
#include "libempathy/empathy-enum-types.h"
#include "libempathy/empathy-location.h"
#include "libempathy/empathy-tp-contact-factory.h"
GeoclueAddress *gc_address;
gboolean reduce_accuracy;
- EmpathyAccountManager *account_manager;
+ TpAccountManager *account_manager;
/* The idle id for publish_on_idle func */
guint timeout_id;
}
static void
-publish_location (EmpathyLocationManager *location_manager,
+publish_location (EmpathyLocationManager *self,
TpConnection *conn,
gboolean force_publication)
{
- EmpathyLocationManagerPriv *priv = GET_PRIV (location_manager);
+ EmpathyLocationManagerPriv *priv = GET_PRIV (self);
guint connection_status = -1;
gboolean can_publish;
EmpathyConf *conf = empathy_conf_get ();
g_object_unref (factory);
}
+typedef struct
+{
+ EmpathyLocationManager *self;
+ gboolean force_publication;
+} PublishToAllData;
+
static void
-publish_to_all_connections (EmpathyLocationManager *location_manager,
- gboolean force_publication)
+publish_to_all_am_prepared_cb (GObject *source_object,
+ GAsyncResult *result,
+ gpointer user_data)
{
- EmpathyLocationManagerPriv *priv = GET_PRIV (location_manager);
- GList *connections = NULL, *l;
+ TpAccountManager *manager = TP_ACCOUNT_MANAGER (source_object);
+ PublishToAllData *data = user_data;
+ GList *accounts, *l;
+ GError *error = NULL;
- connections = empathy_account_manager_dup_connections (priv->account_manager);
- for (l = connections; l; l = l->next)
+ if (!tp_account_manager_prepare_finish (manager, result, &error))
{
- publish_location (location_manager, l->data, force_publication);
- g_object_unref (l->data);
+ DEBUG ("Failed to prepare account manager: %s", error->message);
+ g_error_free (error);
+ goto out;
+ }
+
+ accounts = tp_account_manager_get_valid_accounts (manager);
+ for (l = accounts; l; l = l->next)
+ {
+ TpConnection *conn = tp_account_get_connection (TP_ACCOUNT (l->data));
+
+ if (conn != NULL)
+ publish_location (data->self, conn, data->force_publication);
}
- g_list_free (connections);
+ g_list_free (accounts);
+out:
+ g_object_unref (data->self);
+ g_slice_free (PublishToAllData, data);
+}
+
+static void
+publish_to_all_connections (EmpathyLocationManager *self,
+ gboolean force_publication)
+{
+ EmpathyLocationManagerPriv *priv = GET_PRIV (self);
+ PublishToAllData *data;
+
+ data = g_slice_new0 (PublishToAllData);
+ data->self = g_object_ref (self);
+ data->force_publication = force_publication;
+
+ tp_account_manager_prepare_async (priv->account_manager, NULL,
+ publish_to_all_am_prepared_cb, data);
}
static gboolean
}
static void
-new_connection_cb (EmpathyAccountManager *manager,
- TpConnection *conn,
- gpointer *location_manager)
+new_connection_cb (TpAccount *account,
+ guint old_status,
+ guint new_status,
+ guint reason,
+ gchar *dbus_error_name,
+ GHashTable *details,
+ gpointer *self)
{
- EmpathyLocationManagerPriv *priv = GET_PRIV (location_manager);
+ EmpathyLocationManagerPriv *priv = GET_PRIV (self);
+ TpConnection *conn;
+
+ conn = tp_account_get_connection (account);
+
DEBUG ("New connection %p", conn);
/* Don't publish if it is already planned (ie startup) */
if (priv->timeout_id == 0)
{
- publish_location (EMPATHY_LOCATION_MANAGER (location_manager), conn,
+ publish_location (EMPATHY_LOCATION_MANAGER (self), conn,
FALSE);
}
}
static void
-update_timestamp (EmpathyLocationManager *location_manager)
+update_timestamp (EmpathyLocationManager *self)
{
- EmpathyLocationManagerPriv *priv= GET_PRIV (location_manager);
+ EmpathyLocationManagerPriv *priv= GET_PRIV (self);
GValue *new_value;
gint64 stamp64;
time_t timestamp;
int timestamp,
GHashTable *details,
GeoclueAccuracy *accuracy,
- gpointer location_manager)
+ gpointer self)
{
GeoclueAccuracyLevel level;
- EmpathyLocationManagerPriv *priv = GET_PRIV (location_manager);
+ EmpathyLocationManagerPriv *priv = GET_PRIV (self);
GHashTableIter iter;
gpointer key, value;
DEBUG ("\t - %s: %s", (gchar *) key, (gchar *) value);
}
- update_timestamp (location_manager);
+ update_timestamp (self);
if (priv->timeout_id == 0)
- priv->timeout_id = g_timeout_add_seconds (TIMEOUT, publish_on_idle, location_manager);
+ priv->timeout_id = g_timeout_add_seconds (TIMEOUT, publish_on_idle, self);
}
static void
GHashTable *details,
GeoclueAccuracy *accuracy,
GError *error,
- gpointer location_manager)
+ gpointer self)
{
if (error)
{
}
else
{
- address_changed_cb (address, timestamp, details, accuracy, location_manager);
+ address_changed_cb (address, timestamp, details, accuracy, self);
}
}
double longitude,
double altitude,
GeoclueAccuracy *accuracy,
- gpointer location_manager)
+ gpointer self)
{
- EmpathyLocationManagerPriv *priv = GET_PRIV (location_manager);
+ EmpathyLocationManagerPriv *priv = GET_PRIV (self);
GeoclueAccuracyLevel level;
gdouble mean, horizontal, vertical;
GValue *new_value;
if (priv->reduce_accuracy)
/* Truncate at 1 decimal place */
- longitude = trunc (longitude * 10.0) / 10.0;
+ longitude = ((int) (longitude * 10)) / 10.0;
new_value = tp_g_value_slice_new_double (longitude);
g_hash_table_insert (priv->location, g_strdup (EMPATHY_LOCATION_LON),
{
if (priv->reduce_accuracy)
/* Truncate at 1 decimal place */
- latitude = trunc (latitude * 10.0) / 10.0;
+ latitude = ((int) (latitude * 10)) / 10.0;
new_value = tp_g_value_slice_new_double (latitude);
g_hash_table_replace (priv->location, g_strdup (EMPATHY_LOCATION_LAT),
g_hash_table_remove (priv->location, EMPATHY_LOCATION_ACCURACY);
}
- update_timestamp (location_manager);
+ update_timestamp (self);
if (priv->timeout_id == 0)
- priv->timeout_id = g_timeout_add_seconds (TIMEOUT, publish_on_idle, location_manager);
+ priv->timeout_id = g_timeout_add_seconds (TIMEOUT, publish_on_idle, self);
}
static void
double altitude,
GeoclueAccuracy *accuracy,
GError *error,
- gpointer location_manager)
+ gpointer self)
{
if (error)
{
else
{
position_changed_cb (position, fields, timestamp, latitude, longitude,
- altitude, accuracy, location_manager);
+ altitude, accuracy, self);
}
}
static void
-update_resources (EmpathyLocationManager *location_manager)
+update_resources (EmpathyLocationManager *self)
{
- EmpathyLocationManagerPriv *priv = GET_PRIV (location_manager);
+ EmpathyLocationManagerPriv *priv = GET_PRIV (self);
DEBUG ("Updating resources %d", priv->resources);
}
geoclue_address_get_address_async (priv->gc_address,
- initial_address_cb, location_manager);
+ initial_address_cb, self);
geoclue_position_get_position_async (priv->gc_position,
- initial_position_cb, location_manager);
+ initial_position_cb, self);
}
static void
-setup_geoclue (EmpathyLocationManager *location_manager)
+setup_geoclue (EmpathyLocationManager *self)
{
- EmpathyLocationManagerPriv *priv = GET_PRIV (location_manager);
+ EmpathyLocationManagerPriv *priv = GET_PRIV (self);
GeoclueMaster *master;
GError *error = NULL;
return;
}
- update_resources (location_manager);
+ update_resources (self);
/* Get updated when the position is changes */
priv->gc_position = geoclue_master_client_create_position (
}
g_signal_connect (G_OBJECT (priv->gc_position), "position-changed",
- G_CALLBACK (position_changed_cb), location_manager);
+ G_CALLBACK (position_changed_cb), self);
/* Get updated when the address changes */
priv->gc_address = geoclue_master_client_create_address (
}
g_signal_connect (G_OBJECT (priv->gc_address), "address-changed",
- G_CALLBACK (address_changed_cb), location_manager);
+ G_CALLBACK (address_changed_cb), self);
priv->geoclue_is_setup = TRUE;
}
}
static void
-empathy_location_manager_init (EmpathyLocationManager *location_manager)
+account_manager_prepared_cb (GObject *source_object,
+ GAsyncResult *result,
+ gpointer user_data)
+{
+ GList *accounts, *l;
+ TpAccountManager *account_manager = TP_ACCOUNT_MANAGER (source_object);
+ EmpathyLocationManager *self = user_data;
+ GError *error = NULL;
+
+ if (!tp_account_manager_prepare_finish (account_manager, result, &error))
+ {
+ DEBUG ("Failed to prepare account manager: %s", error->message);
+ g_error_free (error);
+ return;
+ }
+
+ accounts = tp_account_manager_get_valid_accounts (account_manager);
+ for (l = accounts; l != NULL; l = l->next)
+ {
+ TpAccount *account = TP_ACCOUNT (l->data);
+
+ empathy_signal_connect_weak (account, "status-changed",
+ G_CALLBACK (new_connection_cb), G_OBJECT (self));
+ }
+ g_list_free (accounts);
+}
+
+static void
+empathy_location_manager_init (EmpathyLocationManager *self)
{
EmpathyConf *conf;
- EmpathyLocationManagerPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (location_manager,
+ EmpathyLocationManagerPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
EMPATHY_TYPE_LOCATION_MANAGER, EmpathyLocationManagerPriv);
- location_manager->priv = priv;
+ self->priv = priv;
priv->geoclue_is_setup = FALSE;
priv->location = g_hash_table_new_full (g_direct_hash, g_direct_equal,
g_free, (GDestroyNotify) tp_g_value_slice_free);
/* Setup account status callbacks */
- priv->account_manager = empathy_account_manager_dup_singleton ();
- g_signal_connect (priv->account_manager,
- "new-connection",
- G_CALLBACK (new_connection_cb), location_manager);
+ priv->account_manager = tp_account_manager_dup ();
+
+ tp_account_manager_prepare_async (priv->account_manager, NULL,
+ account_manager_prepared_cb, self);
/* Setup settings status callbacks */
conf = empathy_conf_get ();
empathy_conf_notify_add (conf, EMPATHY_PREFS_LOCATION_PUBLISH, publish_cb,
- location_manager);
+ self);
empathy_conf_notify_add (conf, EMPATHY_PREFS_LOCATION_RESOURCE_NETWORK,
- resource_cb, location_manager);
+ resource_cb, self);
empathy_conf_notify_add (conf, EMPATHY_PREFS_LOCATION_RESOURCE_CELL,
- resource_cb, location_manager);
+ resource_cb, self);
empathy_conf_notify_add (conf, EMPATHY_PREFS_LOCATION_RESOURCE_GPS,
- resource_cb, location_manager);
+ resource_cb, self);
empathy_conf_notify_add (conf, EMPATHY_PREFS_LOCATION_REDUCE_ACCURACY,
- accuracy_cb, location_manager);
+ accuracy_cb, self);
- resource_cb (conf, EMPATHY_PREFS_LOCATION_RESOURCE_NETWORK, location_manager);
- resource_cb (conf, EMPATHY_PREFS_LOCATION_RESOURCE_CELL, location_manager);
- resource_cb (conf, EMPATHY_PREFS_LOCATION_RESOURCE_GPS, location_manager);
- accuracy_cb (conf, EMPATHY_PREFS_LOCATION_REDUCE_ACCURACY, location_manager);
- publish_cb (conf, EMPATHY_PREFS_LOCATION_PUBLISH, location_manager);
+ resource_cb (conf, EMPATHY_PREFS_LOCATION_RESOURCE_NETWORK, self);
+ resource_cb (conf, EMPATHY_PREFS_LOCATION_RESOURCE_CELL, self);
+ resource_cb (conf, EMPATHY_PREFS_LOCATION_RESOURCE_GPS, self);
+ accuracy_cb (conf, EMPATHY_PREFS_LOCATION_REDUCE_ACCURACY, self);
+ publish_cb (conf, EMPATHY_PREFS_LOCATION_PUBLISH, self);
}
EmpathyLocationManager *
projects / empathy.git / blobdiff