Pileus Git - ~andy/gtk/blob - gtk/gtksearchenginetracker.c

   1 /*
   2  * Copyright (C) 2009-2011 Nokia <ivan.frade@nokia.com>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library 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  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library. If not, see <http://www.gnu.org/licenses/>.
  16  *
  17  * Authors: Jürg Billeter <juerg.billeter@codethink.co.uk>
  18  *          Martyn Russell <martyn@lanedo.com>
  19  *
  20  * Based on nautilus-search-engine-tracker.c
  21  */
  22
  23 #include "config.h"
  24
  25 #include <string.h>
  26
  27 #include <gio/gio.h>
  28 #include <gmodule.h>
  29 #include <gdk/gdk.h>
  30 #include <gtk/gtk.h>
  31
  32 #include "gtksearchenginetracker.h"
  33
  34 #define DBUS_SERVICE_RESOURCES   "org.freedesktop.Tracker1"
  35 #define DBUS_PATH_RESOURCES      "/org/freedesktop/Tracker1/Resources"
  36 #define DBUS_INTERFACE_RESOURCES "org.freedesktop.Tracker1.Resources"
  37
  38 #define DBUS_SERVICE_STATUS      "org.freedesktop.Tracker1"
  39 #define DBUS_PATH_STATUS         "/org/freedesktop/Tracker1/Status"
  40 #define DBUS_INTERFACE_STATUS    "org.freedesktop.Tracker1.Status"
  41
  42 /* Time in second to wait for service before deciding it's not available */
  43 #define WAIT_TIMEOUT_SECONDS 1
  44
  45 /* Time in second to wait for query results to come back */
  46 #define QUERY_TIMEOUT_SECONDS 10
  47
  48 /* If defined, we use fts:match, this has to be enabled in Tracker to
  49  * work which it usually is. The alternative is to undefine it and
  50  * use filename matching instead. This doesn't use the content of the
  51  * file however.
  52  */
  53 #undef FTS_MATCHING
  54
  55 /*
  56  * GtkSearchEngineTracker object
  57  */
  58 struct _GtkSearchEngineTrackerPrivate
  59 {
  60   GDBusConnection *connection;
  61   GCancellable *cancellable;
  62   GtkQuery *query;
  63   gboolean query_pending;
  64 };
  65
  66 G_DEFINE_TYPE (GtkSearchEngineTracker, _gtk_search_engine_tracker, GTK_TYPE_SEARCH_ENGINE);
  67
  68 static void
  69 finalize (GObject *object)
  70 {
  71   GtkSearchEngineTracker *tracker;
  72
  73   g_debug ("Finalizing GtkSearchEngineTracker");
  74
  75   tracker = GTK_SEARCH_ENGINE_TRACKER (object);
  76
  77   if (tracker->priv->cancellable)
  78     {
  79       g_cancellable_cancel (tracker->priv->cancellable);
  80       g_object_unref (tracker->priv->cancellable);
  81       tracker->priv->cancellable = NULL;
  82     }
  83
  84   if (tracker->priv->query)
  85     {
  86       g_object_unref (tracker->priv->query);
  87       tracker->priv->query = NULL;
  88     }
  89
  90   if (tracker->priv->connection)
  91     {
  92       g_object_unref (tracker->priv->connection);
  93       tracker->priv->connection = NULL;
  94     }
  95
  96   G_OBJECT_CLASS (_gtk_search_engine_tracker_parent_class)->finalize (object);
  97 }
  98
  99 static GDBusConnection *
 100 get_connection (void)
 101 {
 102   GDBusConnection *connection;
 103   GError *error = NULL;
 104   GVariant *reply;
 105
 106   /* Normally I hate sync calls with UIs, but we need to return NULL
 107    * or a GtkSearchEngine as a result of this function.
 108    */
 109   connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
 110
 111   if (error)
 112     {
 113       g_debug ("Couldn't connect to D-Bus session bus, %s", error->message);
 114       g_error_free (error);
 115       return NULL;
 116     }
 117
 118   /* If connection is set, we know it worked. */
 119   g_debug ("Finding out if Tracker is available via D-Bus...");
 120
 121   /* We only wait 1 second max, we expect it to be very fast. If we
 122    * don't get a response by then, clearly we're replaying a journal
 123    * or cleaning up the DB internally. Either way, services is not
 124    * available.
 125    *
 126    * We use the sync call here because we don't expect to be waiting
 127    * long enough to block UI painting.
 128    */
 129   reply = g_dbus_connection_call_sync (connection,
 130                                        DBUS_SERVICE_STATUS,
 131                                        DBUS_PATH_STATUS,
 132                                        DBUS_INTERFACE_STATUS,
 133                                        "Wait",
 134                                        NULL,
 135                                        NULL,
 136                                        G_DBUS_CALL_FLAGS_NONE,
 137                                        WAIT_TIMEOUT_SECONDS * 1000,
 138                                        NULL,
 139                                        &error);
 140
 141   if (error)
 142     {
 143       g_debug ("Tracker is not available, %s", error->message);
 144       g_error_free (error);
 145       g_object_unref (connection);
 146       return NULL;
 147     }
 148
 149   g_variant_unref (reply);
 150
 151   g_debug ("Tracker is ready");
 152
 153   return connection;
 154 }
 155
 156 static void
 157 get_query_results (GtkSearchEngineTracker *engine,
 158                    const gchar            *sparql,
 159                    GAsyncReadyCallback     callback,
 160                    gpointer                user_data)
 161 {
 162   g_dbus_connection_call (engine->priv->connection,
 163                           DBUS_SERVICE_RESOURCES,
 164                           DBUS_PATH_RESOURCES,
 165                           DBUS_INTERFACE_RESOURCES,
 166                           "SparqlQuery",
 167                           g_variant_new ("(s)", sparql),
 168                           NULL,
 169                           G_DBUS_CALL_FLAGS_NONE,
 170                           QUERY_TIMEOUT_SECONDS * 1000,
 171                           engine->priv->cancellable,
 172                           callback,
 173                           user_data);
 174 }
 175
 176 /* Stolen from libtracker-common */
 177 static GList *
 178 string_list_to_gslist (gchar **strv)
 179 {
 180   GList *list;
 181   gsize i;
 182
 183   list = NULL;
 184
 185   for (i = 0; strv[i]; i++)
 186     list = g_list_prepend (list, g_strdup (strv[i]));
 187
 188   return g_list_reverse (list);
 189 }
 190
 191 /* Stolen from libtracker-sparql */
 192 static gchar *
 193 sparql_escape_string (const gchar *literal)
 194 {
 195   GString *str;
 196   const gchar *p;
 197
 198   g_return_val_if_fail (literal != NULL, NULL);
 199
 200   str = g_string_new ("");
 201   p = literal;
 202
 203   while (TRUE)
 204      {
 205       gsize len;
 206
 207       if (!((*p) != '\0'))
 208         break;
 209
 210       len = strcspn ((const gchar *) p, "\t\n\r\b\f\"\\");
 211       g_string_append_len (str, (const gchar *) p, (gssize) ((glong) len));
 212       p = p + len;
 213
 214       switch (*p)
 215         {
 216         case '\t':
 217           g_string_append (str, "\\t");
 218           break;
 219         case '\n':
 220           g_string_append (str, "\\n");
 221           break;
 222         case '\r':
 223           g_string_append (str, "\\r");
 224           break;
 225         case '\b':
 226           g_string_append (str, "\\b");
 227           break;
 228         case '\f':
 229           g_string_append (str, "\\f");
 230           break;
 231         case '"':
 232           g_string_append (str, "\\\"");
 233           break;
 234         case '\\':
 235           g_string_append (str, "\\\\");
 236           break;
 237         default:
 238           continue;
 239         }
 240
 241       p++;
 242      }
 243   return g_string_free (str, FALSE);
 244  }
 245
 246 static void
 247 sparql_append_string_literal (GString     *sparql,
 248                               const gchar *str)
 249 {
 250   gchar *s;
 251
 252   s = sparql_escape_string (str);
 253
 254   g_string_append_c (sparql, '"');
 255   g_string_append (sparql, s);
 256   g_string_append_c (sparql, '"');
 257
 258   g_free (s);
 259 }
 260
 261 static void
 262 sparql_append_string_literal_lower_case (GString     *sparql,
 263                                          const gchar *str)
 264 {
 265   gchar *s;
 266
 267   s = g_utf8_strdown (str, -1);
 268   sparql_append_string_literal (sparql, s);
 269   g_free (s);
 270 }
 271
 272 static void
 273 query_callback (GObject      *object,
 274                 GAsyncResult *res,
 275                 gpointer      user_data)
 276 {
 277   GtkSearchEngineTracker *tracker;
 278   GList *hits;
 279   GVariant *reply;
 280   GVariant *r;
 281   GVariantIter iter;
 282   gchar **result;
 283   GError *error = NULL;
 284   gint i, n;
 285
 286   gdk_threads_enter ();
 287
 288   tracker = GTK_SEARCH_ENGINE_TRACKER (user_data);
 289
 290   tracker->priv->query_pending = FALSE;
 291
 292   reply = g_dbus_connection_call_finish (tracker->priv->connection, res, &error);
 293   if (error)
 294     {
 295       _gtk_search_engine_error (GTK_SEARCH_ENGINE (tracker), error->message);
 296       g_error_free (error);
 297       gdk_threads_leave ();
 298       return;
 299     }
 300
 301   if (!reply)
 302     {
 303       _gtk_search_engine_finished (GTK_SEARCH_ENGINE (tracker));
 304       gdk_threads_leave ();
 305       return;
 306     }
 307
 308   r = g_variant_get_child_value (reply, 0);
 309   g_variant_iter_init (&iter, r);
 310   n = g_variant_iter_n_children (&iter);
 311   result = g_new0 (gchar *, n + 1);
 312   for (i = 0; i < n; i++)
 313     {
 314       GVariant *v;
 315       const gchar **strv;
 316
 317       v = g_variant_iter_next_value (&iter);
 318       strv = g_variant_get_strv (v, NULL);
 319       result[i] = (gchar*)strv[0];
 320       g_free (strv);
 321     }
 322
 323   /* We iterate result by result, not n at a time. */
 324   hits = string_list_to_gslist (result);
 325   _gtk_search_engine_hits_added (GTK_SEARCH_ENGINE (tracker), hits);
 326   _gtk_search_engine_finished (GTK_SEARCH_ENGINE (tracker));
 327   g_list_free (hits);
 328   g_free (result);
 329   g_variant_unref (reply);
 330   g_variant_unref (r);
 331
 332   gdk_threads_leave ();
 333 }
 334
 335 static void
 336 gtk_search_engine_tracker_start (GtkSearchEngine *engine)
 337 {
 338   GtkSearchEngineTracker *tracker;
 339   gchar *search_text;
 340 #ifdef FTS_MATCHING
 341   gchar *location_uri;
 342 #endif
 343   GString *sparql;
 344
 345   tracker = GTK_SEARCH_ENGINE_TRACKER (engine);
 346
 347   if (tracker->priv->query_pending)
 348     {
 349       g_debug ("Attempt to start a new search while one is pending, doing nothing");
 350       return;
 351     }
 352
 353   if (tracker->priv->query == NULL)
 354     {
 355       g_debug ("Attempt to start a new search with no GtkQuery, doing nothing");
 356       return;
 357     }
 358
 359   search_text = _gtk_query_get_text (tracker->priv->query);
 360
 361 #ifdef FTS_MATCHING
 362   location_uri = _gtk_query_get_location (tracker->priv->query);
 363   /* Using FTS: */
 364   sparql = g_string_new ("SELECT nie:url(?urn) "
 365                          "WHERE {"
 366                          "  ?urn a nfo:FileDataObject ;"
 367                          "  tracker:available true ; "
 368                          "  fts:match ");
 369   sparql_append_string_literal (sparql, search_text);
 370
 371   if (location_uri)
 372     {
 373       g_string_append (sparql, " . FILTER (fn:starts-with(nie:url(?urn),");
 374       sparql_append_string_literal (sparql, location_uri);
 375       g_string_append (sparql, "))");
 376     }
 377
 378   g_string_append (sparql, " } ORDER BY DESC(fts:rank(?urn)) ASC(nie:url(?urn))");
 379 #else  /* FTS_MATCHING */
 380   /* Using filename matching: */
 381   sparql = g_string_new ("SELECT nie:url(?urn) "
 382                          "WHERE {"
 383                          "  ?urn a nfo:FileDataObject ;"
 384                          "    tracker:available true ."
 385                          "  FILTER (fn:contains(fn:lower-case(nfo:fileName(?urn)),");
 386   sparql_append_string_literal_lower_case (sparql, search_text);
 387
 388   g_string_append (sparql,
 389                    "))"
 390                    "} ORDER BY DESC(nie:url(?urn)) DESC(nfo:fileName(?urn))");
 391 #endif /* FTS_MATCHING */
 392
 393   tracker->priv->query_pending = TRUE;
 394
 395   get_query_results (tracker, sparql->str, query_callback, tracker);
 396
 397   g_string_free (sparql, TRUE);
 398   g_free (search_text);
 399 }
 400
 401 static void
 402 gtk_search_engine_tracker_stop (GtkSearchEngine *engine)
 403 {
 404   GtkSearchEngineTracker *tracker;
 405
 406   tracker = GTK_SEARCH_ENGINE_TRACKER (engine);
 407
 408   if (tracker->priv->query && tracker->priv->query_pending)
 409     {
 410       g_cancellable_cancel (tracker->priv->cancellable);
 411       tracker->priv->query_pending = FALSE;
 412     }
 413 }
 414
 415 static gboolean
 416 gtk_search_engine_tracker_is_indexed (GtkSearchEngine *engine)
 417 {
 418   return TRUE;
 419 }
 420
 421 static void
 422 gtk_search_engine_tracker_set_query (GtkSearchEngine *engine,
 423                                      GtkQuery        *query)
 424 {
 425   GtkSearchEngineTracker *tracker;
 426
 427   tracker = GTK_SEARCH_ENGINE_TRACKER (engine);
 428
 429   if (query)
 430     g_object_ref (query);
 431
 432   if (tracker->priv->query)
 433     g_object_unref (tracker->priv->query);
 434
 435   tracker->priv->query = query;
 436 }
 437
 438 static void
 439 _gtk_search_engine_tracker_class_init (GtkSearchEngineTrackerClass *class)
 440 {
 441   GObjectClass *gobject_class;
 442   GtkSearchEngineClass *engine_class;
 443
 444   gobject_class = G_OBJECT_CLASS (class);
 445   gobject_class->finalize = finalize;
 446
 447   engine_class = GTK_SEARCH_ENGINE_CLASS (class);
 448   engine_class->set_query = gtk_search_engine_tracker_set_query;
 449   engine_class->start = gtk_search_engine_tracker_start;
 450   engine_class->stop = gtk_search_engine_tracker_stop;
 451   engine_class->is_indexed = gtk_search_engine_tracker_is_indexed;
 452
 453   g_type_class_add_private (gobject_class,
 454                             sizeof (GtkSearchEngineTrackerPrivate));
 455 }
 456
 457 static void
 458 _gtk_search_engine_tracker_init (GtkSearchEngineTracker *engine)
 459 {
 460   engine->priv = G_TYPE_INSTANCE_GET_PRIVATE (engine,
 461                                               GTK_TYPE_SEARCH_ENGINE_TRACKER,
 462                                               GtkSearchEngineTrackerPrivate);
 463 }
 464
 465
 466 GtkSearchEngine *
 467 _gtk_search_engine_tracker_new (void)
 468 {
 469   GtkSearchEngineTracker *engine;
 470   GDBusConnection *connection;
 471
 472   g_debug ("--");
 473
 474   connection = get_connection ();
 475   if (!connection)
 476     return NULL;
 477
 478   g_debug ("Creating GtkSearchEngineTracker...");
 479
 480   engine = g_object_new (GTK_TYPE_SEARCH_ENGINE_TRACKER, NULL);
 481
 482   engine->priv->connection = connection;
 483   engine->priv->cancellable = g_cancellable_new ();
 484   engine->priv->query_pending = FALSE;
 485
 486   return GTK_SEARCH_ENGINE (engine);
 487 }