diff --git a/src/modules/Makefile_geoclue2.mk b/src/modules/Makefile_geoclue2.mk
index 915e25798..33cd9638f 100644
--- a/src/modules/Makefile_geoclue2.mk
+++ b/src/modules/Makefile_geoclue2.mk
@@ -12,7 +12,15 @@ geolocationpkg_LTLIBRARIES = src/modules/geoclue2/module.la
 src_modules_geoclue2_module_la_LIBADD = $(MOD_LIBS)
 src_modules_geoclue2_module_la_CPPFLAGS = $(MOD_CPPFLAGS)
 src_modules_geoclue2_module_la_LDFLAGS = $(MOD_LDFLAGS)
-src_modules_geoclue2_module_la_SOURCES = src/modules/geoclue2/e_mod_main.c
+src_modules_geoclue2_module_la_SOURCES = \
+src/modules/geoclue2/e_mod_main.c \
+src/modules/geoclue2/gen/eldbus_geo_clue2_client.c \
+src/modules/geoclue2/gen/eldbus_geo_clue2_client.h \
+src/modules/geoclue2/gen/eldbus_geo_clue2_location.c \
+src/modules/geoclue2/gen/eldbus_geo_clue2_location.h \
+src/modules/geoclue2/gen/eldbus_geo_clue2_manager.c \
+src/modules/geoclue2/gen/eldbus_geo_clue2_manager.h \
+src/modules/geoclue2/gen/eldbus_utils.h
 
 PHONIES += geolocation install-geolocation
 geolocation: $(geolocationpkg_LTLIBRARIES) $(geolocation_DATA)
diff --git a/src/modules/geoclue2/e_mod_main.c b/src/modules/geoclue2/e_mod_main.c
index c69607ee2..6431e3efc 100644
--- a/src/modules/geoclue2/e_mod_main.c
+++ b/src/modules/geoclue2/e_mod_main.c
@@ -1,14 +1,8 @@
 #include "e.h"
 
-/* TODO
- * o Grey if inUse property is false
- * o Blue if the inUse property is true
- * o Pulsing if an app requests access and the dialog shows?
- * o Dialog with app name and option for Not yet, Never, Only once, Always
- * o List of apps in settings window.
- * o Display accuracy level? Per app?
- */
-
+#include "gen/eldbus_geo_clue2_manager.h"
+#include "gen/eldbus_geo_clue2_client.h"
+#include "gen/eldbus_geo_clue2_location.h"
 
 /* gadcon requirements */
 static E_Gadcon_Client *_gc_init(E_Gadcon *gc, const char *name, const char *id, const char *style);
@@ -37,17 +31,54 @@ struct _Instance
    E_Gadcon_Client *gcc;
    Evas_Object     *o_geoclue2;
    Eina_Bool       in_use;
+   Eldbus_Connection *conn;
+   Eldbus_Service_Interface *iface;
+   Eldbus_Proxy *manager;
+   Eldbus_Proxy *client;
+   Eldbus_Proxy *location;
+   double latitude;
+   double longitude;
+   double accuracy;
+   double altitude;
+   const char *description;
 };
 
 static Eina_List *geoclue2_instances = NULL;
 static E_Module *geoclue2_module = NULL;
 
+void
+cb_client_start(Eldbus_Proxy *proxy EINA_UNUSED, void *data, Eldbus_Pending *pending EINA_UNUSED,
+		Eldbus_Error_Info *error EINA_UNUSED)
+{
+   Instance *inst = data;
+
+   DBG("Client proxy start callback received");
+
+   edje_object_signal_emit(inst->o_geoclue2, "e,state,location_on", "e");
+}
+
+void
+cb_client_stop(Eldbus_Proxy *proxy EINA_UNUSED, void *data, Eldbus_Pending *pending EINA_UNUSED,
+		Eldbus_Error_Info *error EINA_UNUSED)
+{
+   Instance *inst = data;
+
+   DBG("Client proxy stop callback received");
+
+   edje_object_signal_emit(inst->o_geoclue2, "e,state,location_off", "e");
+}
+
 static void
 _geoclue2_cb_mouse_down(void *data, Evas *evas __UNUSED__, Evas_Object *obj __UNUSED__, void *event)
 {
    Instance *inst = data;
    Evas_Event_Mouse_Down *ev = event;
 
+   if (ev->button == 1)
+     {
+        DBG("**** DEBUG **** Left mouse button clicked on icon");
+        geo_clue2_client_start_call(inst->client, cb_client_start, inst);
+     }
    if (ev->button == 3)
      {
         E_Zone *zone;
@@ -55,6 +86,9 @@ _geoclue2_cb_mouse_down(void *data, Evas *evas __UNUSED__, Evas_Object *obj __UN
         E_Menu_Item *mi;
         int x, y;
 
+        DBG("**** DEBUG **** Right mouse button clicked on icon");
+        geo_clue2_client_stop_call(inst->client, cb_client_stop, inst);
+
         zone = e_util_zone_current_get(e_manager_current_get());
 
         m = e_menu_new();
@@ -73,6 +107,108 @@ _geoclue2_cb_mouse_down(void *data, Evas *evas __UNUSED__, Evas_Object *obj __UN
      }
 }
 
+void
+cb_location_prop_latitude_get(void *data EINA_UNUSED, Eldbus_Pending *p EINA_UNUSED,
+		              const char *propname EINA_UNUSED, Eldbus_Proxy *proxy EINA_UNUSED,
+		              Eldbus_Error_Info *error_info EINA_UNUSED, double value)
+{
+   Instance *inst = data;
+   inst->latitude = value;
+
+   DBG("Location property Latitude: %f", value);
+}
+
+void
+cb_location_prop_longitude_get(void *data EINA_UNUSED, Eldbus_Pending *p EINA_UNUSED,
+		               const char *propname EINA_UNUSED, Eldbus_Proxy *proxy EINA_UNUSED,
+		               Eldbus_Error_Info *error_info EINA_UNUSED, double value)
+{
+   Instance *inst = data;
+   inst->longitude = value;
+
+   DBG("Location property Longitude: %f", value);
+}
+
+void
+cb_location_prop_accuracy_get(void *data EINA_UNUSED, Eldbus_Pending *p EINA_UNUSED,
+		              const char *propname EINA_UNUSED, Eldbus_Proxy *proxy EINA_UNUSED,
+		              Eldbus_Error_Info *error_info EINA_UNUSED, double value)
+{
+   Instance *inst = data;
+   inst->accuracy = value;
+
+   DBG("Location property Accuracy: %f", value);
+}
+
+void
+cb_location_prop_altitude_get(void *data EINA_UNUSED, Eldbus_Pending *p EINA_UNUSED,
+		              const char *propname EINA_UNUSED, Eldbus_Proxy *proxy EINA_UNUSED,
+		              Eldbus_Error_Info *error_info EINA_UNUSED, double value)
+{
+   Instance *inst = data;
+   inst->altitude = value;
+
+   DBG("Location property Altitude: %f", value);
+}
+
+void
+cb_location_prop_description_get(void *data EINA_UNUSED, Eldbus_Pending *p EINA_UNUSED,
+		                 const char *propname EINA_UNUSED, Eldbus_Proxy *proxy EINA_UNUSED,
+		                 Eldbus_Error_Info *error_info EINA_UNUSED, const char *value)
+{
+   Instance *inst = data;
+   inst->description = value;
+
+   DBG("Location property Description: %s", value);
+}
+
+void
+cb_client_location_updated_signal(void *data, const Eldbus_Message *msg)
+{
+   const char *new_path, *old_path;
+   Instance *inst = data;
+
+   DBG("Client LocationUpdated signal received");
+
+   if (!eldbus_message_arguments_get(msg, "oo", &old_path, &new_path))
+     {
+        ERR("Error: could not get location update");
+        return;
+     }
+   DBG("Client signal location path old: %s", old_path);
+   DBG("Client signal location path new: %s", new_path);
+
+   inst->location = geo_clue2_location_proxy_get(inst->conn, "org.freedesktop.GeoClue2", new_path);
+   if (!inst->location)
+     {
+        ERR("Error: could not connect to GeoClue2 location proxy");
+        return;
+     }
+
+   geo_clue2_location_latitude_propget(inst->location, cb_location_prop_latitude_get, inst);
+   geo_clue2_location_longitude_propget(inst->location, cb_location_prop_longitude_get, inst);
+   geo_clue2_location_accuracy_propget(inst->location, cb_location_prop_accuracy_get, inst);
+   geo_clue2_location_altitude_propget(inst->location, cb_location_prop_altitude_get, inst);
+   geo_clue2_location_description_propget(inst->location, cb_location_prop_description_get, inst);
+}
+
+void
+cb_client_object_get(Eldbus_Proxy *proxy EINA_UNUSED, void *data, Eldbus_Pending *pending EINA_UNUSED,
+		     Eldbus_Error_Info *error EINA_UNUSED, const char *client_path)
+{
+   Instance *inst = data;
+
+   DBG("Client object path: %s", client_path);
+   inst->client = geo_clue2_client_proxy_get(inst->conn, "org.freedesktop.GeoClue2", client_path);
+   if (!inst->client)
+     {
+        ERR("Error: could not connect to GeoClue2 client proxy");
+        return;
+     }
+
+   eldbus_proxy_signal_handler_add(inst->client, "LocationUpdated", cb_client_location_updated_signal, inst);
+}
+
 static E_Gadcon_Client *
 _gc_init(E_Gadcon *gc, const char *name, const char *id, const char *style)
 {
@@ -80,6 +216,7 @@ _gc_init(E_Gadcon *gc, const char *name, const char *id, const char *style)
    E_Gadcon_Client *gcc;
    Instance *inst;
 
+   eldbus_init();
    inst = E_NEW(Instance, 1);
 
    o = edje_object_add(gc->evas);
@@ -102,6 +239,23 @@ _gc_init(E_Gadcon *gc, const char *name, const char *id, const char *style)
                                   inst);
 
    geoclue2_instances = eina_list_append(geoclue2_instances, inst);
+
+   inst->conn = eldbus_connection_get(ELDBUS_CONNECTION_TYPE_SYSTEM);
+   if (!inst->conn)
+     {
+        ERR("Error: could not get system bus.");
+        return NULL;
+     }
+
+   inst->manager = geo_clue2_manager_proxy_get(inst->conn, "org.freedesktop.GeoClue2", "/org/freedesktop/GeoClue2/Manager");
+   if (!inst->manager)
+     {
+        ERR("Error: could not connect to GeoClue2 manager proxy");
+        return NULL;
+     }
+
+   geo_clue2_manager_get_client_call(inst->manager, cb_client_object_get, inst);
+
    return gcc;
 }
 
@@ -113,7 +267,12 @@ _gc_shutdown(E_Gadcon_Client *gcc)
    inst = gcc->data;
    geoclue2_instances = eina_list_remove(geoclue2_instances, inst);
    evas_object_del(inst->o_geoclue2);
+   geo_clue2_manager_proxy_unref(inst->location);
+   geo_clue2_manager_proxy_unref(inst->client);
+   geo_clue2_manager_proxy_unref(inst->manager);
+   eldbus_connection_unref(inst->conn);
    free(inst);
+   eldbus_shutdown();
 }
 
 static void
diff --git a/src/modules/geoclue2/gen/eldbus_geo_clue2_client.c b/src/modules/geoclue2/gen/eldbus_geo_clue2_client.c
new file mode 100644
index 000000000..73fed906a
--- /dev/null
+++ b/src/modules/geoclue2/gen/eldbus_geo_clue2_client.c
@@ -0,0 +1,442 @@
+#include "eldbus_geo_clue2_client.h"
+
+static int _log_main = -1;
+#undef ERR
+#define ERR(...) EINA_LOG_DOM_ERR(_log_main, __VA_ARGS__);
+int GEO_CLUE2_CLIENT_LOCATION_UPDATED_EVENT = 0;
+
+static void
+cb_geo_clue2_client_start(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
+{
+   void *user_data = eldbus_pending_data_del(pending, "__user_data");
+   Geo_Clue2_Client_Start_Cb cb = data;
+   const char *error, *error_msg;
+   Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
+   if (eldbus_message_error_get(msg, &error, &error_msg))
+     {
+        Eldbus_Error_Info error_info = {error, error_msg};
+        cb(proxy, user_data, pending, &error_info);
+        return;
+     }
+   if (!eldbus_message_arguments_get(msg, ""))
+     {
+        Eldbus_Error_Info error_info = {"", ""};
+        ERR("Error: Getting arguments from message.");
+        cb(proxy, user_data, pending, &error_info);
+        return;
+     }
+   cb(proxy, user_data, pending, NULL);
+   return;
+}
+
+Eldbus_Pending *
+geo_clue2_client_start_call(Eldbus_Proxy *proxy, Geo_Clue2_Client_Start_Cb cb, const void *data)
+{
+   Eldbus_Message *msg;
+   Eldbus_Pending *p;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
+   msg = eldbus_proxy_method_call_new(proxy, "Start");
+   if (!eldbus_message_arguments_append(msg, ""))
+     {
+        ERR("Error: Filling message.");
+        return NULL;
+     }
+   p = eldbus_proxy_send(proxy, msg, cb_geo_clue2_client_start, cb, -1);
+   if (data)
+     eldbus_pending_data_set(p, "__user_data", data);
+   eldbus_pending_data_set(p, "__proxy", proxy);
+   return p;
+}
+
+static void
+cb_geo_clue2_client_stop(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
+{
+   void *user_data = eldbus_pending_data_del(pending, "__user_data");
+   Geo_Clue2_Client_Stop_Cb cb = data;
+   const char *error, *error_msg;
+   Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
+   if (eldbus_message_error_get(msg, &error, &error_msg))
+     {
+        Eldbus_Error_Info error_info = {error, error_msg};
+        cb(proxy, user_data, pending, &error_info);
+        return;
+     }
+   if (!eldbus_message_arguments_get(msg, ""))
+     {
+        Eldbus_Error_Info error_info = {"", ""};
+        ERR("Error: Getting arguments from message.");
+        cb(proxy, user_data, pending, &error_info);
+        return;
+     }
+   cb(proxy, user_data, pending, NULL);
+   return;
+}
+
+Eldbus_Pending *
+geo_clue2_client_stop_call(Eldbus_Proxy *proxy, Geo_Clue2_Client_Stop_Cb cb, const void *data)
+{
+   Eldbus_Message *msg;
+   Eldbus_Pending *p;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
+   msg = eldbus_proxy_method_call_new(proxy, "Stop");
+   if (!eldbus_message_arguments_append(msg, ""))
+     {
+        ERR("Error: Filling message.");
+        return NULL;
+     }
+   p = eldbus_proxy_send(proxy, msg, cb_geo_clue2_client_stop, cb, -1);
+   if (data)
+     eldbus_pending_data_set(p, "__user_data", data);
+   eldbus_pending_data_set(p, "__proxy", proxy);
+   return p;
+}
+
+static void
+geo_clue2_client_location_updated_data_free(void *user_data EINA_UNUSED, void *func_data)
+{
+   Geo_Clue2_Client_LocationUpdated_Data *s_data = func_data;
+   free(s_data->old);
+   free(s_data->new);
+   free(s_data);
+}
+
+static void
+on_geo_clue2_client_location_updated(void *data, const Eldbus_Message *msg)
+{
+   Eldbus_Proxy *proxy = data;
+   Geo_Clue2_Client_LocationUpdated_Data *s_data = calloc(1, sizeof(Geo_Clue2_Client_LocationUpdated_Data));
+   s_data->proxy = proxy;
+   if (!eldbus_message_arguments_get(msg, "oo", &s_data->old, &s_data->new))
+     {
+        ERR("Error: Getting arguments from message.");
+        free(s_data);
+        return;
+     }
+   s_data->old = strdup(s_data->old);
+   s_data->new = strdup(s_data->new);
+   ecore_event_add(GEO_CLUE2_CLIENT_LOCATION_UPDATED_EVENT, s_data, geo_clue2_client_location_updated_data_free, NULL);
+}
+
+static void
+cb_geo_clue2_client_location(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
+{
+   void *user_data = eldbus_pending_data_del(pending, "__user_data");
+   const char *error, *error_msg;
+   Eldbus_Codegen_Property_String_Get_Cb cb = data;
+   Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
+   Eldbus_Message_Iter *variant;
+   const char *v;
+   if (eldbus_message_error_get(msg, &error, &error_msg))
+     {
+        Eldbus_Error_Info error_info = {error, error_msg};
+        cb(user_data, pending, "Location", proxy, &error_info, NULL);
+        return;
+     }
+   if (!eldbus_message_arguments_get(msg, "v", &variant))
+     {
+        Eldbus_Error_Info error_info = {"", ""};
+        cb(user_data, pending, "Location", proxy, &error_info, NULL);
+        return;
+     }
+   if (!eldbus_message_iter_arguments_get(variant, "o", &v))
+     {
+        Eldbus_Error_Info error_info = {"", ""};
+        cb(user_data, pending, "Location", proxy, &error_info, NULL);
+        return;
+     }
+   cb(user_data, pending, "Location", proxy, NULL, v);
+}
+
+Eldbus_Pending *
+geo_clue2_client_location_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_String_Get_Cb cb, const void *data)
+{
+   Eldbus_Pending *p;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
+   p = eldbus_proxy_property_get(proxy, "Location", cb_geo_clue2_client_location, cb);
+   if (data)
+     eldbus_pending_data_set(p, "__user_data", data);
+   eldbus_pending_data_set(p, "__proxy", proxy);
+   return p;
+}
+
+static void
+cb_geo_clue2_client_distance_threshold(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
+{
+   void *user_data = eldbus_pending_data_del(pending, "__user_data");
+   const char *error, *error_msg;
+   Eldbus_Codegen_Property_Uint32_Get_Cb cb = data;
+   Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
+   Eldbus_Message_Iter *variant;
+   unsigned int v;
+   if (eldbus_message_error_get(msg, &error, &error_msg))
+     {
+        Eldbus_Error_Info error_info = {error, error_msg};
+        cb(user_data, pending, "DistanceThreshold", proxy, &error_info, 0);
+        return;
+     }
+   if (!eldbus_message_arguments_get(msg, "v", &variant))
+     {
+        Eldbus_Error_Info error_info = {"", ""};
+        cb(user_data, pending, "DistanceThreshold", proxy, &error_info, 0);
+        return;
+     }
+   if (!eldbus_message_iter_arguments_get(variant, "u", &v))
+     {
+        Eldbus_Error_Info error_info = {"", ""};
+        cb(user_data, pending, "DistanceThreshold", proxy, &error_info, 0);
+        return;
+     }
+   cb(user_data, pending, "DistanceThreshold", proxy, NULL, v);
+}
+
+Eldbus_Pending *
+geo_clue2_client_distance_threshold_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Uint32_Get_Cb cb, const void *data)
+{
+   Eldbus_Pending *p;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
+   p = eldbus_proxy_property_get(proxy, "DistanceThreshold", cb_geo_clue2_client_distance_threshold, cb);
+   if (data)
+     eldbus_pending_data_set(p, "__user_data", data);
+   eldbus_pending_data_set(p, "__proxy", proxy);
+   return p;
+}
+
+static void
+cb_geo_clue2_client_distance_threshold_set(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
+{
+   const char *error, *error_msg;
+   void *user_data = eldbus_pending_data_del(pending, "__user_data");
+   Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
+   Eldbus_Codegen_Property_Set_Cb cb = data;
+   if (eldbus_message_error_get(msg, &error, &error_msg))     {
+        Eldbus_Error_Info error_info = {error, error_msg};
+
+        cb(user_data, "DistanceThreshold", proxy, pending, &error_info);
+        return;
+     }
+   cb(user_data, "DistanceThreshold", proxy, pending, NULL);
+}
+
+Eldbus_Pending *
+geo_clue2_client_distance_threshold_propset(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Set_Cb cb, const void *data, const void *value)
+{
+   Eldbus_Pending *p;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(value, NULL);
+   p = eldbus_proxy_property_set(proxy, "DistanceThreshold", "u", value, cb_geo_clue2_client_distance_threshold_set, data);
+   eldbus_pending_data_set(p, "__user_data", data);
+   eldbus_pending_data_set(p, "__proxy", proxy);
+   return p;
+}
+
+static void
+cb_geo_clue2_client_desktop_id(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
+{
+   void *user_data = eldbus_pending_data_del(pending, "__user_data");
+   const char *error, *error_msg;
+   Eldbus_Codegen_Property_String_Get_Cb cb = data;
+   Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
+   Eldbus_Message_Iter *variant;
+   const char *v;
+   if (eldbus_message_error_get(msg, &error, &error_msg))
+     {
+        Eldbus_Error_Info error_info = {error, error_msg};
+        cb(user_data, pending, "DesktopId", proxy, &error_info, NULL);
+        return;
+     }
+   if (!eldbus_message_arguments_get(msg, "v", &variant))
+     {
+        Eldbus_Error_Info error_info = {"", ""};
+        cb(user_data, pending, "DesktopId", proxy, &error_info, NULL);
+        return;
+     }
+   if (!eldbus_message_iter_arguments_get(variant, "s", &v))
+     {
+        Eldbus_Error_Info error_info = {"", ""};
+        cb(user_data, pending, "DesktopId", proxy, &error_info, NULL);
+        return;
+     }
+   cb(user_data, pending, "DesktopId", proxy, NULL, v);
+}
+
+Eldbus_Pending *
+geo_clue2_client_desktop_id_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_String_Get_Cb cb, const void *data)
+{
+   Eldbus_Pending *p;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
+   p = eldbus_proxy_property_get(proxy, "DesktopId", cb_geo_clue2_client_desktop_id, cb);
+   if (data)
+     eldbus_pending_data_set(p, "__user_data", data);
+   eldbus_pending_data_set(p, "__proxy", proxy);
+   return p;
+}
+
+static void
+cb_geo_clue2_client_desktop_id_set(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
+{
+   const char *error, *error_msg;
+   void *user_data = eldbus_pending_data_del(pending, "__user_data");
+   Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
+   Eldbus_Codegen_Property_Set_Cb cb = data;
+   if (eldbus_message_error_get(msg, &error, &error_msg))     {
+        Eldbus_Error_Info error_info = {error, error_msg};
+
+        cb(user_data, "DesktopId", proxy, pending, &error_info);
+        return;
+     }
+   cb(user_data, "DesktopId", proxy, pending, NULL);
+}
+
+Eldbus_Pending *
+geo_clue2_client_desktop_id_propset(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Set_Cb cb, const void *data, const void *value)
+{
+   Eldbus_Pending *p;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(value, NULL);
+   p = eldbus_proxy_property_set(proxy, "DesktopId", "s", value, cb_geo_clue2_client_desktop_id_set, data);
+   eldbus_pending_data_set(p, "__user_data", data);
+   eldbus_pending_data_set(p, "__proxy", proxy);
+   return p;
+}
+
+static void
+cb_geo_clue2_client_requested_accuracy_level(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
+{
+   void *user_data = eldbus_pending_data_del(pending, "__user_data");
+   const char *error, *error_msg;
+   Eldbus_Codegen_Property_Uint32_Get_Cb cb = data;
+   Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
+   Eldbus_Message_Iter *variant;
+   unsigned int v;
+   if (eldbus_message_error_get(msg, &error, &error_msg))
+     {
+        Eldbus_Error_Info error_info = {error, error_msg};
+        cb(user_data, pending, "RequestedAccuracyLevel", proxy, &error_info, 0);
+        return;
+     }
+   if (!eldbus_message_arguments_get(msg, "v", &variant))
+     {
+        Eldbus_Error_Info error_info = {"", ""};
+        cb(user_data, pending, "RequestedAccuracyLevel", proxy, &error_info, 0);
+        return;
+     }
+   if (!eldbus_message_iter_arguments_get(variant, "u", &v))
+     {
+        Eldbus_Error_Info error_info = {"", ""};
+        cb(user_data, pending, "RequestedAccuracyLevel", proxy, &error_info, 0);
+        return;
+     }
+   cb(user_data, pending, "RequestedAccuracyLevel", proxy, NULL, v);
+}
+
+Eldbus_Pending *
+geo_clue2_client_requested_accuracy_level_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Uint32_Get_Cb cb, const void *data)
+{
+   Eldbus_Pending *p;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
+   p = eldbus_proxy_property_get(proxy, "RequestedAccuracyLevel", cb_geo_clue2_client_requested_accuracy_level, cb);
+   if (data)
+     eldbus_pending_data_set(p, "__user_data", data);
+   eldbus_pending_data_set(p, "__proxy", proxy);
+   return p;
+}
+
+static void
+cb_geo_clue2_client_requested_accuracy_level_set(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
+{
+   const char *error, *error_msg;
+   void *user_data = eldbus_pending_data_del(pending, "__user_data");
+   Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
+   Eldbus_Codegen_Property_Set_Cb cb = data;
+   if (eldbus_message_error_get(msg, &error, &error_msg))     {
+        Eldbus_Error_Info error_info = {error, error_msg};
+
+        cb(user_data, "RequestedAccuracyLevel", proxy, pending, &error_info);
+        return;
+     }
+   cb(user_data, "RequestedAccuracyLevel", proxy, pending, NULL);
+}
+
+Eldbus_Pending *
+geo_clue2_client_requested_accuracy_level_propset(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Set_Cb cb, const void *data, const void *value)
+{
+   Eldbus_Pending *p;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(value, NULL);
+   p = eldbus_proxy_property_set(proxy, "RequestedAccuracyLevel", "u", value, cb_geo_clue2_client_requested_accuracy_level_set, data);
+   eldbus_pending_data_set(p, "__user_data", data);
+   eldbus_pending_data_set(p, "__proxy", proxy);
+   return p;
+}
+
+static void
+cb_geo_clue2_client_active(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
+{
+   void *user_data = eldbus_pending_data_del(pending, "__user_data");
+   const char *error, *error_msg;
+   Eldbus_Codegen_Property_Bool_Get_Cb cb = data;
+   Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
+   Eldbus_Message_Iter *variant;
+   Eina_Bool v;
+   if (eldbus_message_error_get(msg, &error, &error_msg))
+     {
+        Eldbus_Error_Info error_info = {error, error_msg};
+        cb(user_data, pending, "Active", proxy, &error_info, 0);
+        return;
+     }
+   if (!eldbus_message_arguments_get(msg, "v", &variant))
+     {
+        Eldbus_Error_Info error_info = {"", ""};
+        cb(user_data, pending, "Active", proxy, &error_info, 0);
+        return;
+     }
+   if (!eldbus_message_iter_arguments_get(variant, "b", &v))
+     {
+        Eldbus_Error_Info error_info = {"", ""};
+        cb(user_data, pending, "Active", proxy, &error_info, 0);
+        return;
+     }
+   cb(user_data, pending, "Active", proxy, NULL, v);
+}
+
+Eldbus_Pending *
+geo_clue2_client_active_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data)
+{
+   Eldbus_Pending *p;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
+   p = eldbus_proxy_property_get(proxy, "Active", cb_geo_clue2_client_active, cb);
+   if (data)
+     eldbus_pending_data_set(p, "__user_data", data);
+   eldbus_pending_data_set(p, "__proxy", proxy);
+   return p;
+}
+
+void
+geo_clue2_client_log_domain_set(int id)
+{
+   _log_main = id;
+}
+
+void
+geo_clue2_client_proxy_unref(Eldbus_Proxy *proxy)
+{
+   Eldbus_Object *obj = eldbus_proxy_object_get(proxy);
+   eldbus_proxy_unref(proxy);
+   eldbus_object_unref(obj);
+}
+
+Eldbus_Proxy *
+geo_clue2_client_proxy_get(Eldbus_Connection *conn, const char *bus, const char *path)
+{
+   Eldbus_Object *obj;
+   Eldbus_Proxy *proxy;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(conn, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(bus, NULL);
+   if (!path) path = "/";
+   obj = eldbus_object_get(conn, bus, path);
+   proxy = eldbus_proxy_get(obj, "org.freedesktop.GeoClue2.Client");
+   eldbus_proxy_signal_handler_add(proxy, "LocationUpdated", on_geo_clue2_client_location_updated, proxy);
+   if (!GEO_CLUE2_CLIENT_LOCATION_UPDATED_EVENT)
+     GEO_CLUE2_CLIENT_LOCATION_UPDATED_EVENT = ecore_event_type_new();
+   return proxy;
+}
diff --git a/src/modules/geoclue2/gen/eldbus_geo_clue2_client.h b/src/modules/geoclue2/gen/eldbus_geo_clue2_client.h
new file mode 100644
index 000000000..5f73069bb
--- /dev/null
+++ b/src/modules/geoclue2/gen/eldbus_geo_clue2_client.h
@@ -0,0 +1,32 @@
+#ifndef ELDBUS_GEO_CLUE2_CLIENT_H
+#define ELDBUS_GEO_CLUE2_CLIENT_H
+
+#include <Eina.h>
+#include <Ecore.h>
+#include <Eldbus.h>
+#include "eldbus_utils.h"
+
+Eldbus_Proxy *geo_clue2_client_proxy_get(Eldbus_Connection *conn, const char *bus, const char *path);
+void geo_clue2_client_proxy_unref(Eldbus_Proxy *proxy);
+void geo_clue2_client_log_domain_set(int id);
+typedef void (*Geo_Clue2_Client_Start_Cb)(Eldbus_Proxy *proxy, void *data, Eldbus_Pending *pending, Eldbus_Error_Info *error);
+Eldbus_Pending *geo_clue2_client_start_call(Eldbus_Proxy *proxy, Geo_Clue2_Client_Start_Cb cb, const void *data);
+typedef void (*Geo_Clue2_Client_Stop_Cb)(Eldbus_Proxy *proxy, void *data, Eldbus_Pending *pending, Eldbus_Error_Info *error);
+Eldbus_Pending *geo_clue2_client_stop_call(Eldbus_Proxy *proxy, Geo_Clue2_Client_Stop_Cb cb, const void *data);
+extern int GEO_CLUE2_CLIENT_LOCATION_UPDATED_EVENT;
+typedef struct _Geo_Clue2_Client_LocationUpdated_Data
+{
+   Eldbus_Proxy *proxy;
+   char *old;
+   char *new;
+} Geo_Clue2_Client_LocationUpdated_Data;
+Eldbus_Pending *geo_clue2_client_location_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_String_Get_Cb cb, const void *data);
+Eldbus_Pending *geo_clue2_client_distance_threshold_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Uint32_Get_Cb cb, const void *data);
+Eldbus_Pending *geo_clue2_client_distance_threshold_propset(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Set_Cb cb, const void *data, const void *value);
+Eldbus_Pending *geo_clue2_client_desktop_id_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_String_Get_Cb cb, const void *data);
+Eldbus_Pending *geo_clue2_client_desktop_id_propset(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Set_Cb cb, const void *data, const void *value);
+Eldbus_Pending *geo_clue2_client_requested_accuracy_level_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Uint32_Get_Cb cb, const void *data);
+Eldbus_Pending *geo_clue2_client_requested_accuracy_level_propset(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Set_Cb cb, const void *data, const void *value);
+Eldbus_Pending *geo_clue2_client_active_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data);
+
+#endif
diff --git a/src/modules/geoclue2/gen/eldbus_geo_clue2_location.c b/src/modules/geoclue2/gen/eldbus_geo_clue2_location.c
new file mode 100644
index 000000000..53dbf3c3f
--- /dev/null
+++ b/src/modules/geoclue2/gen/eldbus_geo_clue2_location.c
@@ -0,0 +1,242 @@
+#include "eldbus_geo_clue2_location.h"
+
+static int _log_main = -1;
+#undef ERR
+#define ERR(...) EINA_LOG_DOM_ERR(_log_main, __VA_ARGS__);
+
+static void
+cb_geo_clue2_location_latitude(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
+{
+   void *user_data = eldbus_pending_data_del(pending, "__user_data");
+   const char *error, *error_msg;
+   Eldbus_Codegen_Property_Double_Get_Cb cb = data;
+   Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
+   Eldbus_Message_Iter *variant;
+   double v;
+   if (eldbus_message_error_get(msg, &error, &error_msg))
+     {
+        Eldbus_Error_Info error_info = {error, error_msg};
+        cb(user_data, pending, "Latitude", proxy, &error_info, 0);
+        return;
+     }
+   if (!eldbus_message_arguments_get(msg, "v", &variant))
+     {
+        Eldbus_Error_Info error_info = {"", ""};
+        cb(user_data, pending, "Latitude", proxy, &error_info, 0);
+        return;
+     }
+   if (!eldbus_message_iter_arguments_get(variant, "d", &v))
+     {
+        Eldbus_Error_Info error_info = {"", ""};
+        cb(user_data, pending, "Latitude", proxy, &error_info, 0);
+        return;
+     }
+   cb(user_data, pending, "Latitude", proxy, NULL, v);
+}
+
+Eldbus_Pending *
+geo_clue2_location_latitude_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Double_Get_Cb cb, const void *data)
+{
+   Eldbus_Pending *p;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
+   p = eldbus_proxy_property_get(proxy, "Latitude", cb_geo_clue2_location_latitude, cb);
+   if (data)
+     eldbus_pending_data_set(p, "__user_data", data);
+   eldbus_pending_data_set(p, "__proxy", proxy);
+   return p;
+}
+
+static void
+cb_geo_clue2_location_longitude(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
+{
+   void *user_data = eldbus_pending_data_del(pending, "__user_data");
+   const char *error, *error_msg;
+   Eldbus_Codegen_Property_Double_Get_Cb cb = data;
+   Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
+   Eldbus_Message_Iter *variant;
+   double v;
+   if (eldbus_message_error_get(msg, &error, &error_msg))
+     {
+        Eldbus_Error_Info error_info = {error, error_msg};
+        cb(user_data, pending, "Longitude", proxy, &error_info, 0);
+        return;
+     }
+   if (!eldbus_message_arguments_get(msg, "v", &variant))
+     {
+        Eldbus_Error_Info error_info = {"", ""};
+        cb(user_data, pending, "Longitude", proxy, &error_info, 0);
+        return;
+     }
+   if (!eldbus_message_iter_arguments_get(variant, "d", &v))
+     {
+        Eldbus_Error_Info error_info = {"", ""};
+        cb(user_data, pending, "Longitude", proxy, &error_info, 0);
+        return;
+     }
+   cb(user_data, pending, "Longitude", proxy, NULL, v);
+}
+
+Eldbus_Pending *
+geo_clue2_location_longitude_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Double_Get_Cb cb, const void *data)
+{
+   Eldbus_Pending *p;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
+   p = eldbus_proxy_property_get(proxy, "Longitude", cb_geo_clue2_location_longitude, cb);
+   if (data)
+     eldbus_pending_data_set(p, "__user_data", data);
+   eldbus_pending_data_set(p, "__proxy", proxy);
+   return p;
+}
+
+static void
+cb_geo_clue2_location_accuracy(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
+{
+   void *user_data = eldbus_pending_data_del(pending, "__user_data");
+   const char *error, *error_msg;
+   Eldbus_Codegen_Property_Double_Get_Cb cb = data;
+   Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
+   Eldbus_Message_Iter *variant;
+   double v;
+   if (eldbus_message_error_get(msg, &error, &error_msg))
+     {
+        Eldbus_Error_Info error_info = {error, error_msg};
+        cb(user_data, pending, "Accuracy", proxy, &error_info, 0);
+        return;
+     }
+   if (!eldbus_message_arguments_get(msg, "v", &variant))
+     {
+        Eldbus_Error_Info error_info = {"", ""};
+        cb(user_data, pending, "Accuracy", proxy, &error_info, 0);
+        return;
+     }
+   if (!eldbus_message_iter_arguments_get(variant, "d", &v))
+     {
+        Eldbus_Error_Info error_info = {"", ""};
+        cb(user_data, pending, "Accuracy", proxy, &error_info, 0);
+        return;
+     }
+   cb(user_data, pending, "Accuracy", proxy, NULL, v);
+}
+
+Eldbus_Pending *
+geo_clue2_location_accuracy_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Double_Get_Cb cb, const void *data)
+{
+   Eldbus_Pending *p;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
+   p = eldbus_proxy_property_get(proxy, "Accuracy", cb_geo_clue2_location_accuracy, cb);
+   if (data)
+     eldbus_pending_data_set(p, "__user_data", data);
+   eldbus_pending_data_set(p, "__proxy", proxy);
+   return p;
+}
+
+static void
+cb_geo_clue2_location_altitude(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
+{
+   void *user_data = eldbus_pending_data_del(pending, "__user_data");
+   const char *error, *error_msg;
+   Eldbus_Codegen_Property_Double_Get_Cb cb = data;
+   Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
+   Eldbus_Message_Iter *variant;
+   double v;
+   if (eldbus_message_error_get(msg, &error, &error_msg))
+     {
+        Eldbus_Error_Info error_info = {error, error_msg};
+        cb(user_data, pending, "Altitude", proxy, &error_info, 0);
+        return;
+     }
+   if (!eldbus_message_arguments_get(msg, "v", &variant))
+     {
+        Eldbus_Error_Info error_info = {"", ""};
+        cb(user_data, pending, "Altitude", proxy, &error_info, 0);
+        return;
+     }
+   if (!eldbus_message_iter_arguments_get(variant, "d", &v))
+     {
+        Eldbus_Error_Info error_info = {"", ""};
+        cb(user_data, pending, "Altitude", proxy, &error_info, 0);
+        return;
+     }
+   cb(user_data, pending, "Altitude", proxy, NULL, v);
+}
+
+Eldbus_Pending *
+geo_clue2_location_altitude_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Double_Get_Cb cb, const void *data)
+{
+   Eldbus_Pending *p;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
+   p = eldbus_proxy_property_get(proxy, "Altitude", cb_geo_clue2_location_altitude, cb);
+   if (data)
+     eldbus_pending_data_set(p, "__user_data", data);
+   eldbus_pending_data_set(p, "__proxy", proxy);
+   return p;
+}
+
+static void
+cb_geo_clue2_location_description(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
+{
+   void *user_data = eldbus_pending_data_del(pending, "__user_data");
+   const char *error, *error_msg;
+   Eldbus_Codegen_Property_String_Get_Cb cb = data;
+   Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
+   Eldbus_Message_Iter *variant;
+   const char *v;
+   if (eldbus_message_error_get(msg, &error, &error_msg))
+     {
+        Eldbus_Error_Info error_info = {error, error_msg};
+        cb(user_data, pending, "Description", proxy, &error_info, NULL);
+        return;
+     }
+   if (!eldbus_message_arguments_get(msg, "v", &variant))
+     {
+        Eldbus_Error_Info error_info = {"", ""};
+        cb(user_data, pending, "Description", proxy, &error_info, NULL);
+        return;
+     }
+   if (!eldbus_message_iter_arguments_get(variant, "s", &v))
+     {
+        Eldbus_Error_Info error_info = {"", ""};
+        cb(user_data, pending, "Description", proxy, &error_info, NULL);
+        return;
+     }
+   cb(user_data, pending, "Description", proxy, NULL, v);
+}
+
+Eldbus_Pending *
+geo_clue2_location_description_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_String_Get_Cb cb, const void *data)
+{
+   Eldbus_Pending *p;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
+   p = eldbus_proxy_property_get(proxy, "Description", cb_geo_clue2_location_description, cb);
+   if (data)
+     eldbus_pending_data_set(p, "__user_data", data);
+   eldbus_pending_data_set(p, "__proxy", proxy);
+   return p;
+}
+
+void
+geo_clue2_location_log_domain_set(int id)
+{
+   _log_main = id;
+}
+
+void
+geo_clue2_location_proxy_unref(Eldbus_Proxy *proxy)
+{
+   Eldbus_Object *obj = eldbus_proxy_object_get(proxy);
+   eldbus_proxy_unref(proxy);
+   eldbus_object_unref(obj);
+}
+
+Eldbus_Proxy *
+geo_clue2_location_proxy_get(Eldbus_Connection *conn, const char *bus, const char *path)
+{
+   Eldbus_Object *obj;
+   Eldbus_Proxy *proxy;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(conn, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(bus, NULL);
+   if (!path) path = "/";
+   obj = eldbus_object_get(conn, bus, path);
+   proxy = eldbus_proxy_get(obj, "org.freedesktop.GeoClue2.Location");
+   return proxy;
+}
diff --git a/src/modules/geoclue2/gen/eldbus_geo_clue2_location.h b/src/modules/geoclue2/gen/eldbus_geo_clue2_location.h
new file mode 100644
index 000000000..38793a158
--- /dev/null
+++ b/src/modules/geoclue2/gen/eldbus_geo_clue2_location.h
@@ -0,0 +1,18 @@
+#ifndef ELDBUS_GEO_CLUE2_LOCATION_H
+#define ELDBUS_GEO_CLUE2_LOCATION_H
+
+#include <Eina.h>
+#include <Ecore.h>
+#include <Eldbus.h>
+#include "eldbus_utils.h"
+
+Eldbus_Proxy *geo_clue2_location_proxy_get(Eldbus_Connection *conn, const char *bus, const char *path);
+void geo_clue2_location_proxy_unref(Eldbus_Proxy *proxy);
+void geo_clue2_location_log_domain_set(int id);
+Eldbus_Pending *geo_clue2_location_latitude_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Double_Get_Cb cb, const void *data);
+Eldbus_Pending *geo_clue2_location_longitude_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Double_Get_Cb cb, const void *data);
+Eldbus_Pending *geo_clue2_location_accuracy_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Double_Get_Cb cb, const void *data);
+Eldbus_Pending *geo_clue2_location_altitude_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Double_Get_Cb cb, const void *data);
+Eldbus_Pending *geo_clue2_location_description_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_String_Get_Cb cb, const void *data);
+
+#endif
\ No newline at end of file
diff --git a/src/modules/geoclue2/gen/eldbus_geo_clue2_manager.c b/src/modules/geoclue2/gen/eldbus_geo_clue2_manager.c
new file mode 100644
index 000000000..1fea88947
--- /dev/null
+++ b/src/modules/geoclue2/gen/eldbus_geo_clue2_manager.c
@@ -0,0 +1,203 @@
+#include "eldbus_geo_clue2_manager.h"
+
+static int _log_main = -1;
+#undef ERR
+#define ERR(...) EINA_LOG_DOM_ERR(_log_main, __VA_ARGS__);
+
+static void
+cb_geo_clue2_manager_get_client(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
+{
+   void *user_data = eldbus_pending_data_del(pending, "__user_data");
+   Geo_Clue2_Manager_Get_Client_Cb cb = data;
+   const char *error, *error_msg;
+   Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
+   const char *client = NULL;
+   if (eldbus_message_error_get(msg, &error, &error_msg))
+     {
+        Eldbus_Error_Info error_info = {error, error_msg};
+        cb(proxy, user_data, pending, &error_info, client);
+        return;
+     }
+   if (!eldbus_message_arguments_get(msg, "o", &client))
+     {
+        Eldbus_Error_Info error_info = {"", ""};
+        ERR("Error: Getting arguments from message.");
+        cb(proxy, user_data, pending, &error_info, client);
+        return;
+     }
+   cb(proxy, user_data, pending, NULL, client);
+   return;
+}
+
+Eldbus_Pending *
+geo_clue2_manager_get_client_call(Eldbus_Proxy *proxy, Geo_Clue2_Manager_Get_Client_Cb cb, const void *data)
+{
+   Eldbus_Message *msg;
+   Eldbus_Pending *p;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
+   msg = eldbus_proxy_method_call_new(proxy, "GetClient");
+   if (!eldbus_message_arguments_append(msg, ""))
+     {
+        ERR("Error: Filling message.");
+        return NULL;
+     }
+   p = eldbus_proxy_send(proxy, msg, cb_geo_clue2_manager_get_client, cb, -1);
+   if (data)
+     eldbus_pending_data_set(p, "__user_data", data);
+   eldbus_pending_data_set(p, "__proxy", proxy);
+   return p;
+}
+
+static void
+cb_geo_clue2_manager_add_agent(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
+{
+   void *user_data = eldbus_pending_data_del(pending, "__user_data");
+   Geo_Clue2_Manager_Add_Agent_Cb cb = data;
+   const char *error, *error_msg;
+   Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
+   if (eldbus_message_error_get(msg, &error, &error_msg))
+     {
+        Eldbus_Error_Info error_info = {error, error_msg};
+        cb(proxy, user_data, pending, &error_info);
+        return;
+     }
+   if (!eldbus_message_arguments_get(msg, ""))
+     {
+        Eldbus_Error_Info error_info = {"", ""};
+        ERR("Error: Getting arguments from message.");
+        cb(proxy, user_data, pending, &error_info);
+        return;
+     }
+   cb(proxy, user_data, pending, NULL);
+   return;
+}
+
+Eldbus_Pending *
+geo_clue2_manager_add_agent_call(Eldbus_Proxy *proxy, Geo_Clue2_Manager_Add_Agent_Cb cb, const void *data, const char *id)
+{
+   Eldbus_Message *msg;
+   Eldbus_Pending *p;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
+   msg = eldbus_proxy_method_call_new(proxy, "AddAgent");
+   if (!eldbus_message_arguments_append(msg, "s", id))
+     {
+        ERR("Error: Filling message.");
+        return NULL;
+     }
+   p = eldbus_proxy_send(proxy, msg, cb_geo_clue2_manager_add_agent, cb, -1);
+   if (data)
+     eldbus_pending_data_set(p, "__user_data", data);
+   eldbus_pending_data_set(p, "__proxy", proxy);
+   return p;
+}
+
+static void
+cb_geo_clue2_manager_in_use(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
+{
+   void *user_data = eldbus_pending_data_del(pending, "__user_data");
+   const char *error, *error_msg;
+   Eldbus_Codegen_Property_Bool_Get_Cb cb = data;
+   Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
+   Eldbus_Message_Iter *variant;
+   Eina_Bool v;
+   if (eldbus_message_error_get(msg, &error, &error_msg))
+     {
+        Eldbus_Error_Info error_info = {error, error_msg};
+        cb(user_data, pending, "InUse", proxy, &error_info, 0);
+        return;
+     }
+   if (!eldbus_message_arguments_get(msg, "v", &variant))
+     {
+        Eldbus_Error_Info error_info = {"", ""};
+        cb(user_data, pending, "InUse", proxy, &error_info, 0);
+        return;
+     }
+   if (!eldbus_message_iter_arguments_get(variant, "b", &v))
+     {
+        Eldbus_Error_Info error_info = {"", ""};
+        cb(user_data, pending, "InUse", proxy, &error_info, 0);
+        return;
+     }
+   cb(user_data, pending, "InUse", proxy, NULL, v);
+}
+
+Eldbus_Pending *
+geo_clue2_manager_in_use_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data)
+{
+   Eldbus_Pending *p;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
+   p = eldbus_proxy_property_get(proxy, "InUse", cb_geo_clue2_manager_in_use, cb);
+   if (data)
+     eldbus_pending_data_set(p, "__user_data", data);
+   eldbus_pending_data_set(p, "__proxy", proxy);
+   return p;
+}
+
+static void
+cb_geo_clue2_manager_available_accuracy_level(void *data, const Eldbus_Message *msg, Eldbus_Pending *pending)
+{
+   void *user_data = eldbus_pending_data_del(pending, "__user_data");
+   const char *error, *error_msg;
+   Eldbus_Codegen_Property_Uint32_Get_Cb cb = data;
+   Eldbus_Proxy *proxy = eldbus_pending_data_del(pending, "__proxy");
+   Eldbus_Message_Iter *variant;
+   unsigned int v;
+   if (eldbus_message_error_get(msg, &error, &error_msg))
+     {
+        Eldbus_Error_Info error_info = {error, error_msg};
+        cb(user_data, pending, "AvailableAccuracyLevel", proxy, &error_info, 0);
+        return;
+     }
+   if (!eldbus_message_arguments_get(msg, "v", &variant))
+     {
+        Eldbus_Error_Info error_info = {"", ""};
+        cb(user_data, pending, "AvailableAccuracyLevel", proxy, &error_info, 0);
+        return;
+     }
+   if (!eldbus_message_iter_arguments_get(variant, "u", &v))
+     {
+        Eldbus_Error_Info error_info = {"", ""};
+        cb(user_data, pending, "AvailableAccuracyLevel", proxy, &error_info, 0);
+        return;
+     }
+   cb(user_data, pending, "AvailableAccuracyLevel", proxy, NULL, v);
+}
+
+Eldbus_Pending *
+geo_clue2_manager_available_accuracy_level_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Uint32_Get_Cb cb, const void *data)
+{
+   Eldbus_Pending *p;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(proxy, NULL);
+   p = eldbus_proxy_property_get(proxy, "AvailableAccuracyLevel", cb_geo_clue2_manager_available_accuracy_level, cb);
+   if (data)
+     eldbus_pending_data_set(p, "__user_data", data);
+   eldbus_pending_data_set(p, "__proxy", proxy);
+   return p;
+}
+
+void
+geo_clue2_manager_log_domain_set(int id)
+{
+   _log_main = id;
+}
+
+void
+geo_clue2_manager_proxy_unref(Eldbus_Proxy *proxy)
+{
+   Eldbus_Object *obj = eldbus_proxy_object_get(proxy);
+   eldbus_proxy_unref(proxy);
+   eldbus_object_unref(obj);
+}
+
+Eldbus_Proxy *
+geo_clue2_manager_proxy_get(Eldbus_Connection *conn, const char *bus, const char *path)
+{
+   Eldbus_Object *obj;
+   Eldbus_Proxy *proxy;
+   EINA_SAFETY_ON_NULL_RETURN_VAL(conn, NULL);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(bus, NULL);
+   if (!path) path = "/";
+   obj = eldbus_object_get(conn, bus, path);
+   proxy = eldbus_proxy_get(obj, "org.freedesktop.GeoClue2.Manager");
+   return proxy;
+}
diff --git a/src/modules/geoclue2/gen/eldbus_geo_clue2_manager.h b/src/modules/geoclue2/gen/eldbus_geo_clue2_manager.h
new file mode 100644
index 000000000..b96323a46
--- /dev/null
+++ b/src/modules/geoclue2/gen/eldbus_geo_clue2_manager.h
@@ -0,0 +1,19 @@
+#ifndef ELDBUS_GEO_CLUE2_MANAGER_H
+#define ELDBUS_GEO_CLUE2_MANAGER_H
+
+#include <Eina.h>
+#include <Ecore.h>
+#include <Eldbus.h>
+#include "eldbus_utils.h"
+
+Eldbus_Proxy *geo_clue2_manager_proxy_get(Eldbus_Connection *conn, const char *bus, const char *path);
+void geo_clue2_manager_proxy_unref(Eldbus_Proxy *proxy);
+void geo_clue2_manager_log_domain_set(int id);
+typedef void (*Geo_Clue2_Manager_Get_Client_Cb)(Eldbus_Proxy *proxy, void *data, Eldbus_Pending *pending, Eldbus_Error_Info *error, const char *client);
+Eldbus_Pending *geo_clue2_manager_get_client_call(Eldbus_Proxy *proxy, Geo_Clue2_Manager_Get_Client_Cb cb, const void *data);
+typedef void (*Geo_Clue2_Manager_Add_Agent_Cb)(Eldbus_Proxy *proxy, void *data, Eldbus_Pending *pending, Eldbus_Error_Info *error);
+Eldbus_Pending *geo_clue2_manager_add_agent_call(Eldbus_Proxy *proxy, Geo_Clue2_Manager_Add_Agent_Cb cb, const void *data, const char *id);
+Eldbus_Pending *geo_clue2_manager_in_use_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Bool_Get_Cb cb, const void *data);
+Eldbus_Pending *geo_clue2_manager_available_accuracy_level_propget(Eldbus_Proxy *proxy, Eldbus_Codegen_Property_Uint32_Get_Cb cb, const void *data);
+
+#endif
\ No newline at end of file
diff --git a/src/modules/geoclue2/gen/eldbus_utils.h b/src/modules/geoclue2/gen/eldbus_utils.h
new file mode 100644
index 000000000..db4f9ae39
--- /dev/null
+++ b/src/modules/geoclue2/gen/eldbus_utils.h
@@ -0,0 +1,24 @@
+#ifndef ELDBUS_UTILS_H
+#define ELDBUS_UTILS_H 1
+
+typedef struct _Eldbus_Error_Info
+{
+   const char *error;
+   const char *message;
+} Eldbus_Error_Info;
+
+typedef void (*Eldbus_Codegen_Property_Set_Cb)(void *data, const char *propname, Eldbus_Proxy *proxy, Eldbus_Pending *p, Eldbus_Error_Info *error_info);
+
+typedef void (*Eldbus_Codegen_Property_String_Get_Cb)(void *data, Eldbus_Pending *p, const char *propname, Eldbus_Proxy *proxy, Eldbus_Error_Info *error_info, const char *value);
+typedef void (*Eldbus_Codegen_Property_Int32_Get_Cb)(void *data, Eldbus_Pending *p, const char *propname, Eldbus_Proxy *proxy, Eldbus_Error_Info *error_info, int value);
+typedef void (*Eldbus_Codegen_Property_Byte_Get_Cb)(void *data, Eldbus_Pending *p, const char *propname, Eldbus_Proxy *proxy, Eldbus_Error_Info *error_info, unsigned char value);
+typedef void (*Eldbus_Codegen_Property_Bool_Get_Cb)(void *data, Eldbus_Pending *p, const char *propname, Eldbus_Proxy *proxy, Eldbus_Error_Info *error_info, Eina_Bool value);
+typedef void (*Eldbus_Codegen_Property_Int16_Get_Cb)(void *data, Eldbus_Pending *p, const char *propname, Eldbus_Proxy *proxy, Eldbus_Error_Info *error_info, short int value);
+typedef void (*Eldbus_Codegen_Property_Uint16_Get_Cb)(void *data, Eldbus_Pending *p, const char *propname, Eldbus_Proxy *proxy, Eldbus_Error_Info *error_info, unsigned short int value);
+typedef void (*Eldbus_Codegen_Property_Uint32_Get_Cb)(void *data, Eldbus_Pending *p, const char *propname, Eldbus_Proxy *proxy, Eldbus_Error_Info *error_info, unsigned int value);
+typedef void (*Eldbus_Codegen_Property_Double_Get_Cb)(void *data, Eldbus_Pending *p, const char *propname, Eldbus_Proxy *proxy, Eldbus_Error_Info *error_info, double value);
+typedef void (*Eldbus_Codegen_Property_Int64_Get_Cb)(void *data, Eldbus_Pending *p, const char *propname, Eldbus_Proxy *proxy, Eldbus_Error_Info *error_info, int64_t value);
+typedef void (*Eldbus_Codegen_Property_Uint64_Get_Cb)(void *data, Eldbus_Pending *p, const char *propname, Eldbus_Proxy *proxy, Eldbus_Error_Info *error_info, uint64_t value);
+typedef void (*Eldbus_Codegen_Property_Complex_Get_Cb)(void *data, Eldbus_Pending *p, const char *propname, Eldbus_Proxy *proxy, Eldbus_Error_Info *error_info, Eina_Value *value);
+
+#endif
\ No newline at end of file