void GeolocationClient::startUpdating() { ASSERT(!m_geoclueClient); GRefPtr<GeoclueMaster> master = adoptGRef(geoclue_master_get_default()); GRefPtr<GeoclueMasterClient> client = adoptGRef(geoclue_master_create_client(master.get(), 0, 0)); if (!client) { errorOccured(_("Could not connect to location provider.")); return; } GOwnPtr<GError> error; GeoclueAccuracyLevel accuracyLevel = m_enableHighAccuracy ? GEOCLUE_ACCURACY_LEVEL_DETAILED : GEOCLUE_ACCURACY_LEVEL_LOCALITY; if (!geoclue_master_client_set_requirements(client.get(), accuracyLevel, 0, false, GEOCLUE_RESOURCE_ALL, &error.outPtr())) { errorOccured(error->message); return; } m_geocluePosition = adoptGRef(geoclue_master_client_create_position(client.get(), &error.outPtr())); if (!m_geocluePosition) { errorOccured(error->message); return; } m_geoclueClient = client; geoclue_position_get_position_async(m_geocluePosition.get(), reinterpret_cast<GeocluePositionCallback>(getPositionCallback), this); g_signal_connect(G_OBJECT(m_geocluePosition.get()), "position-changed", G_CALLBACK(positionChangedCallback), this); m_isUpdating = true; }
int main (int argc, char **argv) { GError *error = NULL; GMainLoop *mainloop; GeoclueMaster *master; GeoclueMasterClient *client; GeocluePosition *position; g_type_init (); master = geoclue_master_get_default (); client = geoclue_master_create_client (master, NULL, NULL); g_object_unref (master); g_signal_connect (G_OBJECT (client), "position-provider-changed", G_CALLBACK (provider_changed_cb), NULL); /* We want provider that has detailed accuracy and emits signals. * The provider is allowed to use any resources available. */ if (!geoclue_master_client_set_requirements (client, GEOCLUE_ACCURACY_LEVEL_LOCALITY, 0, TRUE, GEOCLUE_RESOURCE_ALL, NULL)){ g_printerr ("Setting requirements failed"); g_object_unref (client); return 1; } position = geoclue_master_client_create_position (client, &error); if (!position) { g_warning ("Creating GeocluePosition failed: %s", error->message); g_error_free (error); g_object_unref (client); return 1; } g_signal_connect (G_OBJECT (position), "position-changed", G_CALLBACK (position_changed_cb), NULL); geoclue_position_get_position_async (position, (GeocluePositionCallback) position_callback, NULL); mainloop = g_main_loop_new (NULL, FALSE); g_main_loop_run (mainloop); g_main_loop_unref (mainloop); g_object_unref (client); g_object_unref (position); return 0; }
int location_geoclue_start(location_geoclue_state_t *state) { if (state->provider && state->provider_path) { state->position = geoclue_position_new(state->provider, state->provider_path); } else { GError *error = NULL; GeoclueMaster *master = geoclue_master_get_default(); GeoclueMasterClient *client = geoclue_master_create_client(master, NULL, &error); g_object_unref(master); if (client == NULL) { g_printerr(_("Unable to obtain master client: %s\n"), error->message); g_error_free(error); return -1; } if (!geoclue_master_client_set_requirements(client, GEOCLUE_ACCURACY_LEVEL_REGION, 0, FALSE, GEOCLUE_RESOURCE_NETWORK, &error)) { g_printerr(_("Can't set requirements for master: %s\n"), error->message); g_error_free(error); g_object_unref(client); return -1; } state->position = geoclue_master_client_create_position(client, NULL); g_object_unref(client); } gchar *name = NULL; if (geoclue_provider_get_provider_info(GEOCLUE_PROVIDER(state->position), &name, NULL, NULL)) { fprintf(stdout, _("Started Geoclue provider `%s'.\n"), name); g_free(name); } else { fputs(_("Could not find a usable Geoclue provider.\n"), stderr); fputs(_("Try setting name and path to specify which to use.\n"), stderr); return -1; } return 0; }
// // 1.) Initialize Geoclue with our requirements // 2.) Try to get a GeocluePosition // 3.) Update the Information and get the current position // // TODO: Also get GeoclueVelocity but there is no master client // API for that. // bool GeolocationServiceGtk::startUpdating(PositionOptions* options) { ASSERT(!m_geoclueClient); m_lastPosition = 0; m_lastError = 0; GOwnPtr<GError> error; GeoclueMaster* master = geoclue_master_get_default(); GeoclueMasterClient* client = geoclue_master_create_client(master, 0, 0); g_object_unref(master); if (!client) { setError(PositionError::POSITION_UNAVAILABLE, "Could not connect to location provider."); return false; } GeoclueAccuracyLevel accuracyLevel = GEOCLUE_ACCURACY_LEVEL_LOCALITY; int timeout = 0; if (options) { accuracyLevel = options->enableHighAccuracy() ? GEOCLUE_ACCURACY_LEVEL_DETAILED : GEOCLUE_ACCURACY_LEVEL_LOCALITY; if (options->hasTimeout()) timeout = options->timeout(); } gboolean result = geoclue_master_client_set_requirements(client, accuracyLevel, timeout, false, GEOCLUE_RESOURCE_ALL, &error.outPtr()); if (!result) { setError(PositionError::POSITION_UNAVAILABLE, error->message); g_object_unref(client); return false; } m_geocluePosition = geoclue_master_client_create_position(client, &error.outPtr()); if (!m_geocluePosition) { setError(PositionError::POSITION_UNAVAILABLE, error->message); g_object_unref(client); return false; } m_geoclueClient = client; geoclue_position_get_position_async(m_geocluePosition, (GeocluePositionCallback)getPositionCallback, this); g_signal_connect(G_OBJECT(m_geocluePosition), "position-changed", G_CALLBACK(position_changed), this); return true; }
static void emerillon_window_init (EmerillonWindow *self) { GdkGeometry geometry; GeoclueMaster *master = NULL; GError *error = NULL; gint width, height; self->priv = EMERILLON_WINDOW_GET_PRIVATE (self); self->priv->position_auto_update = FALSE; /* GSettings. */ self->priv->settings_ui = g_settings_new (EMERILLON_SCHEMA_UI); /* Extension setup */ self->priv->ext_set = peas_extension_set_new (peas_engine_get_default (), PEAS_TYPE_ACTIVATABLE, NULL); peas_extension_set_call (self->priv->ext_set, "activate"); g_signal_connect (self->priv->ext_set, "extension-added", G_CALLBACK (on_extension_added), self); g_signal_connect (self->priv->ext_set, "extension-removed", G_CALLBACK (on_extension_removed), self); /* Window setup. */ geometry.min_width = 400; geometry.min_height = 350; gtk_window_set_geometry_hints (GTK_WINDOW (self), GTK_WIDGET (self), &geometry,GDK_HINT_MIN_SIZE); /* Set the window size */ width = g_settings_get_int (self->priv->settings_ui, EMERILLON_CONF_UI_WINDOW_WIDTH); height = g_settings_get_int (self->priv->settings_ui, EMERILLON_CONF_UI_WINDOW_HEIGHT); if (width > 0 && height > 0) gtk_window_set_default_size (GTK_WINDOW (self), width, height); else gtk_window_set_default_size (GTK_WINDOW (self), 640, 450); /* Current position. */ master = geoclue_master_get_default (); self->priv->geoclue_client = geoclue_master_create_client (master, NULL, &error); if (!self->priv->geoclue_client) { g_warning ("Creating Geoclue Master client failed: %s", error->message); g_error_free (error); g_object_unref (master); return; } g_object_unref (master); geoclue_master_client_set_requirements (self->priv->geoclue_client, GEOCLUE_ACCURACY_LEVEL_COUNTRY, 0, FALSE, GEOCLUE_RESOURCE_ALL, NULL); self->priv->geoclue_position = geoclue_master_client_create_position (self->priv->geoclue_client, &error); if (self->priv->geoclue_position) { g_object_set_data (G_OBJECT (self->priv->geoclue_position), "client", self->priv->geoclue_client); g_signal_connect(self->priv->geoclue_position, "position-changed", G_CALLBACK(position_changed_cb), NULL); } else { g_warning ("Getting Geoclue Position Failed: %s", error->message); g_error_free (error); if (self->priv->geoclue_client) g_object_unref (self->priv->geoclue_client); } }