libempathy-gtk/empathy-location-manager.c

   1 /*
   2  * Copyright (C) 2009 Collabora Ltd.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of the
   7  * License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public
  15  * License along with this program; if not, write to the
  16  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  17  * Boston, MA  02110-1301  USA
  18  *
  19  * Authors: Pierre-Luc Beaudoin <pierre-luc.beaudoin@collabora.co.uk>
  20  */
  21
  22 #include "config.h"
  23
  24 #include <string.h>
  25 #include <time.h>
  26
  27 #include <glib/gi18n.h>
  28
  29 #include <telepathy-glib/account-manager.h>
  30 #include <telepathy-glib/util.h>
  31
  32 #include <geoclue/geoclue-master.h>
  33
  34 #include <extensions/extensions.h>
  35
  36 #include "empathy-location-manager.h"
  37 #include "empathy-conf.h"
  38
  39 #include "libempathy/empathy-enum-types.h"
  40 #include "libempathy/empathy-location.h"
  41 #include "libempathy/empathy-tp-contact-factory.h"
  42 #include "libempathy/empathy-utils.h"
  43
  44 #define DEBUG_FLAG EMPATHY_DEBUG_LOCATION
  45 #include "libempathy/empathy-debug.h"
  46
  47 /* Seconds before updating the location */
  48 #define TIMEOUT 10
  49 static EmpathyLocationManager *location_manager = NULL;
  50
  51 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyLocationManager)
  52 typedef struct {
  53     gboolean geoclue_is_setup;
  54     /* Contains the location to be sent to accounts.  Geoclue is used
  55      * to populate it.  This HashTable uses Telepathy's style (string,
  56      * GValue). Keys are defined in empathy-location.h
  57      */
  58     GHashTable *location;
  59
  60     GeoclueResourceFlags resources;
  61     GeoclueMasterClient *gc_client;
  62     GeocluePosition *gc_position;
  63     GeoclueAddress *gc_address;
  64
  65     gboolean reduce_accuracy;
  66     TpAccountManager *account_manager;
  67
  68     /* The idle id for publish_on_idle func */
  69     guint timeout_id;
  70 } EmpathyLocationManagerPriv;
  71
  72 G_DEFINE_TYPE (EmpathyLocationManager, empathy_location_manager, G_TYPE_OBJECT);
  73
  74 static GObject *
  75 location_manager_constructor (GType type,
  76     guint n_construct_params,
  77     GObjectConstructParam *construct_params)
  78 {
  79   GObject *retval;
  80
  81   if (location_manager == NULL)
  82     {
  83       retval = G_OBJECT_CLASS (empathy_location_manager_parent_class)->constructor
  84           (type, n_construct_params, construct_params);
  85
  86       location_manager = EMPATHY_LOCATION_MANAGER (retval);
  87       g_object_add_weak_pointer (retval, (gpointer) &location_manager);
  88     }
  89   else
  90     {
  91       retval = g_object_ref (location_manager);
  92     }
  93
  94   return retval;
  95 }
  96
  97 static void
  98 location_manager_dispose (GObject *object)
  99 {
 100   EmpathyLocationManagerPriv *priv = GET_PRIV (object);
 101   void (*dispose) (GObject *) =
 102     G_OBJECT_CLASS (empathy_location_manager_parent_class)->dispose;
 103
 104   if (priv->account_manager != NULL)
 105   {
 106     g_object_unref (priv->account_manager);
 107     priv->account_manager = NULL;
 108   }
 109
 110   if (priv->gc_client != NULL)
 111   {
 112     g_object_unref (priv->gc_client);
 113     priv->gc_client = NULL;
 114   }
 115
 116   if (priv->gc_position != NULL)
 117   {
 118     g_object_unref (priv->gc_position);
 119     priv->gc_position = NULL;
 120   }
 121
 122   if (priv->gc_address != NULL)
 123   {
 124     g_object_unref (priv->gc_address);
 125     priv->gc_address = NULL;
 126   }
 127
 128   if (priv->location != NULL)
 129   {
 130     g_hash_table_unref (priv->location);
 131     priv->location = NULL;
 132   }
 133
 134   if (dispose != NULL)
 135     dispose (object);
 136 }
 137
 138 static void
 139 location_manager_get_property (GObject *object,
 140                       guint param_id,
 141                       GValue *value,
 142                       GParamSpec *pspec)
 143 {
 144   /*EmpathyLocationManagerPriv *priv = GET_PRIV (object); */
 145
 146   switch (param_id)
 147     {
 148       default:
 149         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 150         break;
 151     };
 152 }
 153
 154 static void
 155 location_manager_set_property (GObject *object,
 156                       guint param_id,
 157                       const GValue *value,
 158                       GParamSpec *pspec)
 159 {
 160   /* EmpathyLocationManagerPriv *priv = GET_PRIV (object); */
 161
 162   switch (param_id)
 163     {
 164       default:
 165         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 166         break;
 167     };
 168 }
 169
 170 static void
 171 empathy_location_manager_class_init (EmpathyLocationManagerClass *class)
 172 {
 173   GObjectClass *object_class;
 174
 175   object_class = G_OBJECT_CLASS (class);
 176
 177   object_class->constructor = location_manager_constructor;
 178   object_class->dispose = location_manager_dispose;
 179   object_class->get_property = location_manager_get_property;
 180   object_class->set_property = location_manager_set_property;
 181
 182   g_type_class_add_private (object_class, sizeof (EmpathyLocationManagerPriv));
 183 }
 184
 185 static void
 186 publish_location (EmpathyLocationManager *self,
 187     TpConnection *conn,
 188     gboolean force_publication)
 189 {
 190   EmpathyLocationManagerPriv *priv = GET_PRIV (self);
 191   guint connection_status = -1;
 192   gboolean can_publish;
 193   EmpathyConf *conf = empathy_conf_get ();
 194   EmpathyTpContactFactory *factory;
 195
 196   if (!conn)
 197     return;
 198
 199   if (!force_publication)
 200     {
 201       if (!empathy_conf_get_bool (conf, EMPATHY_PREFS_LOCATION_PUBLISH,
 202             &can_publish))
 203         return;
 204
 205       if (!can_publish)
 206         return;
 207     }
 208
 209   connection_status = tp_connection_get_status (conn, NULL);
 210
 211   if (connection_status != TP_CONNECTION_STATUS_CONNECTED)
 212     return;
 213
 214   DEBUG ("Publishing %s location to connection %p",
 215       (g_hash_table_size (priv->location) == 0 ? "empty" : ""),
 216       conn);
 217
 218   factory = empathy_tp_contact_factory_dup_singleton (conn);
 219   empathy_tp_contact_factory_set_location (factory, priv->location);
 220   g_object_unref (factory);
 221 }
 222
 223 typedef struct
 224 {
 225   EmpathyLocationManager *self;
 226   gboolean force_publication;
 227 } PublishToAllData;
 228
 229 static void
 230 publish_to_all_am_prepared_cb (GObject *source_object,
 231     GAsyncResult *result,
 232     gpointer user_data)
 233 {
 234   TpAccountManager *manager = TP_ACCOUNT_MANAGER (source_object);
 235   PublishToAllData *data = user_data;
 236   GList *accounts, *l;
 237   GError *error = NULL;
 238
 239   if (!tp_account_manager_prepare_finish (manager, result, &error))
 240     {
 241       DEBUG ("Failed to prepare account manager: %s", error->message);
 242       g_error_free (error);
 243       goto out;
 244     }
 245
 246   accounts = tp_account_manager_get_valid_accounts (manager);
 247   for (l = accounts; l; l = l->next)
 248     {
 249       TpConnection *conn = tp_account_get_connection (TP_ACCOUNT (l->data));
 250
 251       if (conn != NULL)
 252         publish_location (data->self, conn, data->force_publication);
 253     }
 254   g_list_free (accounts);
 255
 256 out:
 257   g_object_unref (data->self);
 258   g_slice_free (PublishToAllData, data);
 259 }
 260
 261 static void
 262 publish_to_all_connections (EmpathyLocationManager *self,
 263     gboolean force_publication)
 264 {
 265   EmpathyLocationManagerPriv *priv = GET_PRIV (self);
 266   PublishToAllData *data;
 267
 268   data = g_slice_new0 (PublishToAllData);
 269   data->self = g_object_ref (self);
 270   data->force_publication = force_publication;
 271
 272   tp_account_manager_prepare_async (priv->account_manager, NULL,
 273       publish_to_all_am_prepared_cb, data);
 274 }
 275
 276 static gboolean
 277 publish_on_idle (gpointer user_data)
 278 {
 279   EmpathyLocationManager *manager = EMPATHY_LOCATION_MANAGER (user_data);
 280   EmpathyLocationManagerPriv *priv = GET_PRIV (manager);
 281
 282   priv->timeout_id = 0;
 283   publish_to_all_connections (manager, TRUE);
 284   return FALSE;
 285 }
 286
 287 static void
 288 new_connection_cb (TpAccount *account,
 289     guint old_status,
 290     guint new_status,
 291     guint reason,
 292     gchar *dbus_error_name,
 293     GHashTable *details,
 294     gpointer *self)
 295 {
 296   EmpathyLocationManagerPriv *priv = GET_PRIV (self);
 297   TpConnection *conn;
 298
 299   conn = tp_account_get_connection (account);
 300
 301   DEBUG ("New connection %p", conn);
 302
 303   /* Don't publish if it is already planned (ie startup) */
 304   if (priv->timeout_id == 0)
 305     {
 306       publish_location (EMPATHY_LOCATION_MANAGER (self), conn,
 307           FALSE);
 308     }
 309 }
 310
 311 static void
 312 update_timestamp (EmpathyLocationManager *self)
 313 {
 314   EmpathyLocationManagerPriv *priv= GET_PRIV (self);
 315   GValue *new_value;
 316   gint64 stamp64;
 317   time_t timestamp;
 318
 319   timestamp = time (NULL);
 320   stamp64 = (gint64) timestamp;
 321   new_value = tp_g_value_slice_new_int64 (stamp64);
 322   g_hash_table_insert (priv->location, g_strdup (EMPATHY_LOCATION_TIMESTAMP),
 323       new_value);
 324   DEBUG ("\t - Timestamp: %" G_GINT64_FORMAT, stamp64);
 325 }
 326
 327 static void
 328 address_changed_cb (GeoclueAddress *address,
 329                     int timestamp,
 330                     GHashTable *details,
 331                     GeoclueAccuracy *accuracy,
 332                     gpointer self)
 333 {
 334   GeoclueAccuracyLevel level;
 335   EmpathyLocationManagerPriv *priv = GET_PRIV (self);
 336   GHashTableIter iter;
 337   gpointer key, value;
 338
 339   geoclue_accuracy_get_details (accuracy, &level, NULL, NULL);
 340   DEBUG ("New address (accuracy level %d):", level);
 341   /* FIXME: Publish accuracy level also considering the position's */
 342
 343   g_hash_table_remove (priv->location, EMPATHY_LOCATION_STREET);
 344   g_hash_table_remove (priv->location, EMPATHY_LOCATION_AREA);
 345   g_hash_table_remove (priv->location, EMPATHY_LOCATION_REGION);
 346   g_hash_table_remove (priv->location, EMPATHY_LOCATION_COUNTRY);
 347   g_hash_table_remove (priv->location, EMPATHY_LOCATION_COUNTRY_CODE);
 348   g_hash_table_remove (priv->location, EMPATHY_LOCATION_POSTAL_CODE);
 349
 350   if (g_hash_table_size (details) == 0)
 351     {
 352       DEBUG ("\t - (Empty)");
 353       return;
 354     }
 355
 356   g_hash_table_iter_init (&iter, details);
 357   while (g_hash_table_iter_next (&iter, &key, &value))
 358     {
 359       GValue *new_value;
 360       /* Discard street information if reduced accuracy is on */
 361       if (priv->reduce_accuracy &&
 362           !tp_strdiff (key, EMPATHY_LOCATION_STREET))
 363         continue;
 364
 365       new_value = tp_g_value_slice_new_string (value);
 366       g_hash_table_insert (priv->location, g_strdup (key), new_value);
 367
 368       DEBUG ("\t - %s: %s", (gchar *) key, (gchar *) value);
 369     }
 370
 371   update_timestamp (self);
 372   if (priv->timeout_id == 0)
 373     priv->timeout_id = g_timeout_add_seconds (TIMEOUT, publish_on_idle, self);
 374 }
 375
 376 static void
 377 initial_address_cb (GeoclueAddress *address,
 378                     int timestamp,
 379                     GHashTable *details,
 380                     GeoclueAccuracy *accuracy,
 381                     GError *error,
 382                     gpointer self)
 383 {
 384   if (error)
 385     {
 386       DEBUG ("Error: %s", error->message);
 387       g_error_free (error);
 388     }
 389   else
 390     {
 391       address_changed_cb (address, timestamp, details, accuracy, self);
 392     }
 393 }
 394
 395 static void
 396 position_changed_cb (GeocluePosition *position,
 397                      GeocluePositionFields fields,
 398                      int timestamp,
 399                      double latitude,
 400                      double longitude,
 401                      double altitude,
 402                      GeoclueAccuracy *accuracy,
 403                      gpointer self)
 404 {
 405   EmpathyLocationManagerPriv *priv = GET_PRIV (self);
 406   GeoclueAccuracyLevel level;
 407   gdouble mean, horizontal, vertical;
 408   GValue *new_value;
 409
 410
 411   geoclue_accuracy_get_details (accuracy, &level, &horizontal, &vertical);
 412   DEBUG ("New position (accuracy level %d)", level);
 413   if (level == GEOCLUE_ACCURACY_LEVEL_NONE)
 414     return;
 415
 416   if (fields & GEOCLUE_POSITION_FIELDS_LONGITUDE)
 417     {
 418
 419       if (priv->reduce_accuracy)
 420         /* Truncate at 1 decimal place */
 421         longitude = ((int) (longitude * 10)) / 10.0;
 422
 423       new_value = tp_g_value_slice_new_double (longitude);
 424       g_hash_table_insert (priv->location, g_strdup (EMPATHY_LOCATION_LON),
 425           new_value);
 426       DEBUG ("\t - Longitude: %f", longitude);
 427     }
 428   else
 429     {
 430       g_hash_table_remove (priv->location, EMPATHY_LOCATION_LON);
 431     }
 432
 433   if (fields & GEOCLUE_POSITION_FIELDS_LATITUDE)
 434     {
 435       if (priv->reduce_accuracy)
 436         /* Truncate at 1 decimal place */
 437         latitude = ((int) (latitude * 10)) / 10.0;
 438
 439       new_value = tp_g_value_slice_new_double (latitude);
 440       g_hash_table_replace (priv->location, g_strdup (EMPATHY_LOCATION_LAT),
 441           new_value);
 442       DEBUG ("\t - Latitude: %f", latitude);
 443     }
 444   else
 445     {
 446       g_hash_table_remove (priv->location, EMPATHY_LOCATION_LAT);
 447     }
 448
 449   if (fields & GEOCLUE_POSITION_FIELDS_ALTITUDE)
 450     {
 451       new_value = tp_g_value_slice_new_double (altitude);
 452       g_hash_table_replace (priv->location, g_strdup (EMPATHY_LOCATION_ALT),
 453           new_value);
 454       DEBUG ("\t - Altitude: %f", altitude);
 455     }
 456   else
 457     {
 458       g_hash_table_remove (priv->location, EMPATHY_LOCATION_ALT);
 459     }
 460
 461   if (level == GEOCLUE_ACCURACY_LEVEL_DETAILED)
 462     {
 463       mean = (horizontal + vertical) / 2.0;
 464       new_value = tp_g_value_slice_new_double (mean);
 465       g_hash_table_replace (priv->location,
 466           g_strdup (EMPATHY_LOCATION_ACCURACY), new_value);
 467       DEBUG ("\t - Accuracy: %f", mean);
 468     }
 469   else
 470     {
 471       g_hash_table_remove (priv->location, EMPATHY_LOCATION_ACCURACY);
 472     }
 473
 474   update_timestamp (self);
 475   if (priv->timeout_id == 0)
 476     priv->timeout_id = g_timeout_add_seconds (TIMEOUT, publish_on_idle, self);
 477 }
 478
 479 static void
 480 initial_position_cb (GeocluePosition *position,
 481                      GeocluePositionFields fields,
 482                      int timestamp,
 483                      double latitude,
 484                      double longitude,
 485                      double altitude,
 486                      GeoclueAccuracy *accuracy,
 487                      GError *error,
 488                      gpointer self)
 489 {
 490   if (error)
 491     {
 492       DEBUG ("Error: %s", error->message);
 493       g_error_free (error);
 494     }
 495   else
 496     {
 497       position_changed_cb (position, fields, timestamp, latitude, longitude,
 498           altitude, accuracy, self);
 499     }
 500 }
 501
 502 static gboolean
 503 set_requirements (EmpathyLocationManager *self)
 504 {
 505   EmpathyLocationManagerPriv *priv = GET_PRIV (self);
 506   GError *error = NULL;
 507
 508   if (!geoclue_master_client_set_requirements (priv->gc_client,
 509           GEOCLUE_ACCURACY_LEVEL_COUNTRY, 0, FALSE, priv->resources,
 510           &error))
 511     {
 512       DEBUG ("set_requirements failed: %s", error->message);
 513       g_error_free (error);
 514       return FALSE;
 515     }
 516
 517   return TRUE;
 518 }
 519
 520 static void
 521 update_resources (EmpathyLocationManager *self)
 522 {
 523   EmpathyLocationManagerPriv *priv = GET_PRIV (self);
 524
 525   DEBUG ("Updating resources %d", priv->resources);
 526
 527   if (!priv->geoclue_is_setup)
 528     return;
 529
 530   /* As per Geoclue bug #15126, using NONE results in no address
 531    * being found as geoclue-manual report an empty address with
 532    * accuracy = NONE */
 533   if (!set_requirements (self))
 534     return;
 535
 536   geoclue_address_get_address_async (priv->gc_address,
 537       initial_address_cb, self);
 538   geoclue_position_get_position_async (priv->gc_position,
 539       initial_position_cb, self);
 540 }
 541
 542 static void
 543 setup_geoclue (EmpathyLocationManager *self)
 544 {
 545   EmpathyLocationManagerPriv *priv = GET_PRIV (self);
 546
 547   GeoclueMaster *master;
 548   GError *error = NULL;
 549
 550   DEBUG ("Setting up Geoclue");
 551   master = geoclue_master_get_default ();
 552   priv->gc_client = geoclue_master_create_client (master, NULL, &error);
 553   g_object_unref (master);
 554
 555   if (priv->gc_client == NULL)
 556     {
 557       DEBUG ("Failed to GeoclueMasterClient: %s", error->message);
 558       g_error_free (error);
 559       return;
 560     }
 561
 562   if (!set_requirements (self))
 563     return;
 564
 565   /* Get updated when the position is changes */
 566   priv->gc_position = geoclue_master_client_create_position (
 567       priv->gc_client, &error);
 568   if (priv->gc_position == NULL)
 569     {
 570       DEBUG ("Failed to create GeocluePosition: %s", error->message);
 571       g_error_free (error);
 572       return;
 573     }
 574
 575   g_signal_connect (G_OBJECT (priv->gc_position), "position-changed",
 576       G_CALLBACK (position_changed_cb), self);
 577
 578   /* Get updated when the address changes */
 579   priv->gc_address = geoclue_master_client_create_address (
 580       priv->gc_client, &error);
 581   if (priv->gc_address == NULL)
 582     {
 583       DEBUG ("Failed to create GeoclueAddress: %s", error->message);
 584       g_error_free (error);
 585       return;
 586     }
 587
 588   g_signal_connect (G_OBJECT (priv->gc_address), "address-changed",
 589       G_CALLBACK (address_changed_cb), self);
 590
 591   priv->geoclue_is_setup = TRUE;
 592 }
 593
 594 static void
 595 publish_cb (EmpathyConf *conf,
 596             const gchar *key,
 597             gpointer user_data)
 598 {
 599   EmpathyLocationManager *manager = EMPATHY_LOCATION_MANAGER (user_data);
 600   EmpathyLocationManagerPriv *priv = GET_PRIV (manager);
 601   gboolean can_publish;
 602
 603   DEBUG ("Publish Conf changed");
 604
 605
 606   if (!empathy_conf_get_bool (conf, key, &can_publish))
 607     return;
 608
 609   if (can_publish)
 610     {
 611       if (!priv->geoclue_is_setup)
 612         setup_geoclue (manager);
 613       /* if still not setup than the init failed */
 614       if (!priv->geoclue_is_setup)
 615         return;
 616
 617       geoclue_address_get_address_async (priv->gc_address,
 618           initial_address_cb, manager);
 619       geoclue_position_get_position_async (priv->gc_position,
 620           initial_position_cb, manager);
 621     }
 622   else
 623     {
 624       /* As per XEP-0080: send an empty location to have remove current
 625        * location from the servers
 626        */
 627       g_hash_table_remove_all (priv->location);
 628       publish_to_all_connections (manager, TRUE);
 629     }
 630
 631 }
 632
 633 static void
 634 resource_cb (EmpathyConf  *conf,
 635              const gchar *key,
 636              gpointer user_data)
 637 {
 638   EmpathyLocationManager *manager = EMPATHY_LOCATION_MANAGER (user_data);
 639   EmpathyLocationManagerPriv *priv = GET_PRIV (manager);
 640   GeoclueResourceFlags resource = 0;
 641   gboolean resource_enabled;
 642
 643   DEBUG ("%s changed", key);
 644
 645   if (!empathy_conf_get_bool (conf, key, &resource_enabled))
 646     return;
 647
 648   if (!tp_strdiff (key, EMPATHY_PREFS_LOCATION_RESOURCE_NETWORK))
 649     resource = GEOCLUE_RESOURCE_NETWORK;
 650   if (!tp_strdiff (key, EMPATHY_PREFS_LOCATION_RESOURCE_CELL))
 651     resource = GEOCLUE_RESOURCE_CELL;
 652   if (!tp_strdiff (key, EMPATHY_PREFS_LOCATION_RESOURCE_GPS))
 653     resource = GEOCLUE_RESOURCE_GPS;
 654
 655   if (resource_enabled)
 656     priv->resources |= resource;
 657   else
 658     priv->resources &= ~resource;
 659
 660   if (priv->geoclue_is_setup)
 661     update_resources (manager);
 662 }
 663
 664 static void
 665 accuracy_cb (EmpathyConf  *conf,
 666              const gchar *key,
 667              gpointer user_data)
 668 {
 669   EmpathyLocationManager *manager = EMPATHY_LOCATION_MANAGER (user_data);
 670   EmpathyLocationManagerPriv *priv = GET_PRIV (manager);
 671
 672   gboolean enabled;
 673
 674   DEBUG ("%s changed", key);
 675
 676   if (!empathy_conf_get_bool (conf, key, &enabled))
 677     return;
 678   priv->reduce_accuracy = enabled;
 679
 680   if (!priv->geoclue_is_setup)
 681     return;
 682
 683   geoclue_address_get_address_async (priv->gc_address,
 684       initial_address_cb, manager);
 685   geoclue_position_get_position_async (priv->gc_position,
 686       initial_position_cb, manager);
 687 }
 688
 689 static void
 690 account_manager_prepared_cb (GObject *source_object,
 691     GAsyncResult *result,
 692     gpointer user_data)
 693 {
 694   GList *accounts, *l;
 695   TpAccountManager *account_manager = TP_ACCOUNT_MANAGER (source_object);
 696   EmpathyLocationManager *self = user_data;
 697   GError *error = NULL;
 698
 699   if (!tp_account_manager_prepare_finish (account_manager, result, &error))
 700     {
 701       DEBUG ("Failed to prepare account manager: %s", error->message);
 702       g_error_free (error);
 703       return;
 704     }
 705
 706   accounts = tp_account_manager_get_valid_accounts (account_manager);
 707   for (l = accounts; l != NULL; l = l->next)
 708     {
 709       TpAccount *account = TP_ACCOUNT (l->data);
 710
 711       empathy_signal_connect_weak (account, "status-changed",
 712           G_CALLBACK (new_connection_cb), G_OBJECT (self));
 713     }
 714   g_list_free (accounts);
 715 }
 716
 717 static void
 718 empathy_location_manager_init (EmpathyLocationManager *self)
 719 {
 720   EmpathyConf               *conf;
 721   EmpathyLocationManagerPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
 722       EMPATHY_TYPE_LOCATION_MANAGER, EmpathyLocationManagerPriv);
 723
 724   self->priv = priv;
 725   priv->geoclue_is_setup = FALSE;
 726   priv->location = g_hash_table_new_full (g_direct_hash, g_direct_equal,
 727       g_free, (GDestroyNotify) tp_g_value_slice_free);
 728
 729   /* Setup account status callbacks */
 730   priv->account_manager = tp_account_manager_dup ();
 731
 732   tp_account_manager_prepare_async (priv->account_manager, NULL,
 733       account_manager_prepared_cb, self);
 734
 735   /* Setup settings status callbacks */
 736   conf = empathy_conf_get ();
 737   empathy_conf_notify_add (conf, EMPATHY_PREFS_LOCATION_PUBLISH, publish_cb,
 738       self);
 739   empathy_conf_notify_add (conf, EMPATHY_PREFS_LOCATION_RESOURCE_NETWORK,
 740       resource_cb, self);
 741   empathy_conf_notify_add (conf, EMPATHY_PREFS_LOCATION_RESOURCE_CELL,
 742       resource_cb, self);
 743   empathy_conf_notify_add (conf, EMPATHY_PREFS_LOCATION_RESOURCE_GPS,
 744       resource_cb, self);
 745   empathy_conf_notify_add (conf, EMPATHY_PREFS_LOCATION_REDUCE_ACCURACY,
 746       accuracy_cb, self);
 747
 748   resource_cb (conf, EMPATHY_PREFS_LOCATION_RESOURCE_NETWORK, self);
 749   resource_cb (conf, EMPATHY_PREFS_LOCATION_RESOURCE_CELL, self);
 750   resource_cb (conf, EMPATHY_PREFS_LOCATION_RESOURCE_GPS, self);
 751   accuracy_cb (conf, EMPATHY_PREFS_LOCATION_REDUCE_ACCURACY, self);
 752   publish_cb (conf, EMPATHY_PREFS_LOCATION_PUBLISH, self);
 753 }
 754
 755 EmpathyLocationManager *
 756 empathy_location_manager_dup_singleton (void)
 757 {
 758   return EMPATHY_LOCATION_MANAGER (g_object_new (EMPATHY_TYPE_LOCATION_MANAGER,
 759       NULL));
 760 }