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

   1 /*
   2  * Copyright (C) 2009-2010 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, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  *
  18  * Authors: Jürg Billeter <juerg.billeter@codethink.co.uk>
  19  *          Martyn Russell <martyn@lanedo.com>
  20  *
  21  * Based on nautilus-search-engine-tracker.c
  22  */
  23
  24 #include "config.h"
  25
  26 #include <gio/gio.h>
  27 #include <gmodule.h>
  28
  29 #include "gtksearchenginetracker.h"
  30
  31 /* If defined, we use fts:match, this has to be enabled in Tracker to
  32  * work which it usually is. The alternative is to undefine it and
  33  * use filename matching instead. This doesn't use the content of the
  34  * file however.
  35  */
  36 #undef FTS_MATCHING
  37
  38 #define MODULE_FILENAME "libtracker-sparql-0.10.so.0"
  39
  40 #define MODULE_MAP(a)   { #a, (gpointer *)&a }
  41
  42 /* Connection object */
  43 typedef struct _TrackerSparqlConnection TrackerSparqlConnection;
  44
  45 #define TRACKER_SPARQL_TYPE_CONNECTION (tracker_sparql_connection_get_type ())
  46 #define TRACKER_SPARQL_CONNECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TRACKER_SPARQL_TYPE_CONNECTION, TrackerSparqlConnection))
  47
  48 /* Cursor object */
  49 typedef struct _TrackerSparqlCursor TrackerSparqlCursor;
  50
  51 #define TRACKER_SPARQL_TYPE_CURSOR (tracker_sparql_cursor_get_type ())
  52 #define TRACKER_SPARQL_CURSOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TRACKER_SPARQL_TYPE_CURSOR, TrackerSparqlCursor))
  53
  54 /* API */
  55 static GType                     (*tracker_sparql_connection_get_type)     (void) = NULL;
  56 static TrackerSparqlConnection * (*tracker_sparql_connection_get)          (GCancellable             *cancellable,
  57                                                                             GError                  **error) = NULL;
  58 static void                      (*tracker_sparql_connection_query_async)  (TrackerSparqlConnection  *self,
  59                                                                             const gchar              *sparql,
  60                                                                             GCancellable             *cancellable,
  61                                                                             GAsyncReadyCallback       callback,
  62                                                                             gpointer                  user_data) = NULL;
  63 static TrackerSparqlCursor *     (*tracker_sparql_connection_query_finish) (TrackerSparqlConnection  *self,
  64                                                                             GAsyncResult             *_res_,
  65                                                                             GError                  **error) = NULL;
  66 static GType                     (*tracker_sparql_cursor_get_type)         (void) = NULL;
  67 static void                      (*tracker_sparql_cursor_next_async)       (TrackerSparqlCursor      *self,
  68                                                                             GCancellable             *cancellable,
  69                                                                             GAsyncReadyCallback       callback,
  70                                                                             gpointer                  user_data) = NULL;
  71 static gboolean                  (*tracker_sparql_cursor_next_finish)      (TrackerSparqlCursor      *self,
  72                                                                             GAsyncResult             *_res_,
  73                                                                             GError                  **error) = NULL;
  74 static const gchar *             (*tracker_sparql_cursor_get_string)       (TrackerSparqlCursor      *self,
  75                                                                             gint                     *column,
  76                                                                             glong                    *length) = NULL;
  77 static gchar *                   (*tracker_sparql_escape_string)           (const gchar              *literal) = NULL;
  78
  79 static struct TrackerFunctions
  80 {
  81         const char *name;
  82         gpointer *pointer;
  83 } funcs[] = {
  84         MODULE_MAP (tracker_sparql_connection_get_type),
  85         MODULE_MAP (tracker_sparql_connection_get),
  86         MODULE_MAP (tracker_sparql_connection_query_async),
  87         MODULE_MAP (tracker_sparql_connection_query_finish),
  88         MODULE_MAP (tracker_sparql_cursor_get_type),
  89         MODULE_MAP (tracker_sparql_cursor_next_async),
  90         MODULE_MAP (tracker_sparql_cursor_next_finish),
  91         MODULE_MAP (tracker_sparql_cursor_get_string),
  92         MODULE_MAP (tracker_sparql_escape_string)
  93 };
  94
  95 static gboolean
  96 init (void)
  97 {
  98   static gboolean inited = FALSE;
  99   gint i;
 100   GModule *m;
 101   GModuleFlags flags;
 102
 103   if (inited)
 104           return TRUE;
 105
 106   flags = G_MODULE_BIND_LAZY | G_MODULE_BIND_LOCAL;
 107
 108   /* Only support 0.10 onwards */
 109   if ((m = g_module_open (MODULE_FILENAME, flags)) == NULL)
 110           {
 111                   g_debug ("No tracker backend available or it is not new enough");
 112                   g_debug ("Only available using '%s'", MODULE_FILENAME);
 113                   return FALSE;
 114           }
 115
 116   inited = TRUE;
 117
 118   /* Check for the symbols we need */
 119   for (i = 0; i < G_N_ELEMENTS (funcs); i++)
 120           {
 121                   if (!g_module_symbol (m, funcs[i].name, funcs[i].pointer))
 122                           {
 123                                   g_warning ("Missing symbol '%s' in libtracker-sparql\n",
 124                                              funcs[i].name);
 125                                   g_module_close (m);
 126
 127                                   for (i = 0; i < G_N_ELEMENTS (funcs); i++)
 128                                           funcs[i].pointer = NULL;
 129
 130                                   return FALSE;
 131                           }
 132             }
 133
 134   g_debug ("Loaded Tracker library and all required symbols");
 135
 136   return TRUE;
 137 }
 138
 139 /*
 140  * GtkSearchEngineTracker object
 141  */
 142 struct _GtkSearchEngineTrackerPrivate
 143 {
 144   TrackerSparqlConnection *connection;
 145         GCancellable *cancellable;
 146   GtkQuery *query;
 147   gboolean query_pending;
 148 };
 149
 150 G_DEFINE_TYPE (GtkSearchEngineTracker, _gtk_search_engine_tracker, GTK_TYPE_SEARCH_ENGINE);
 151
 152 static void cursor_callback (GObject      *object,
 153                              GAsyncResult *result,
 154                              gpointer      user_data);
 155
 156 static void
 157 finalize (GObject *object)
 158 {
 159   GtkSearchEngineTracker *tracker;
 160
 161   tracker = GTK_SEARCH_ENGINE_TRACKER (object);
 162
 163   if (tracker->priv->cancellable)
 164           {
 165                   g_cancellable_cancel (tracker->priv->cancellable);
 166                   g_object_unref (tracker->priv->cancellable);
 167                   tracker->priv->cancellable = NULL;
 168           }
 169
 170   if (tracker->priv->query)
 171     {
 172       g_object_unref (tracker->priv->query);
 173       tracker->priv->query = NULL;
 174     }
 175
 176   if (tracker->priv->connection)
 177           {
 178                   g_object_unref (tracker->priv->connection);
 179                   tracker->priv->connection = NULL;
 180           }
 181
 182   G_OBJECT_CLASS (_gtk_search_engine_tracker_parent_class)->finalize (object);
 183 }
 184
 185 static void
 186 cursor_next (GtkSearchEngineTracker *tracker,
 187              TrackerSparqlCursor    *cursor)
 188 {
 189         tracker_sparql_cursor_next_async (cursor,
 190                                           tracker->priv->cancellable,
 191                                           cursor_callback,
 192                                           tracker);
 193 }
 194
 195 static void
 196 cursor_callback (GObject      *object,
 197                  GAsyncResult *result,
 198                  gpointer      user_data)
 199 {
 200   GtkSearchEngineTracker *tracker;
 201   GError *error = NULL;
 202   TrackerSparqlCursor *cursor;
 203         GList *hits;
 204   gboolean success;
 205
 206   tracker = GTK_SEARCH_ENGINE_TRACKER (user_data);
 207
 208         cursor = TRACKER_SPARQL_CURSOR (object);
 209         success = tracker_sparql_cursor_next_finish (cursor, result, &error);
 210
 211   if (error)
 212     {
 213       _gtk_search_engine_error (GTK_SEARCH_ENGINE (tracker), error->message);
 214
 215       g_error_free (error);
 216
 217       if (cursor)
 218               g_object_unref (cursor);
 219
 220       return;
 221     }
 222
 223   if (!success)
 224           {
 225                   _gtk_search_engine_finished (GTK_SEARCH_ENGINE (tracker));
 226
 227                   if (cursor)
 228                           g_object_unref (cursor);
 229
 230                   return;
 231           }
 232
 233   /* We iterate result by result, not n at a time. */
 234   hits = g_list_append (NULL, (gchar*) tracker_sparql_cursor_get_string (cursor, 0, NULL));
 235   _gtk_search_engine_hits_added (GTK_SEARCH_ENGINE (tracker), hits);
 236   g_list_free (hits);
 237
 238   /* Get next */
 239   cursor_next (tracker, cursor);
 240 }
 241
 242 static void
 243 query_callback (GObject      *object,
 244                 GAsyncResult *result,
 245                 gpointer      user_data)
 246 {
 247   GtkSearchEngineTracker *tracker;
 248   TrackerSparqlConnection *connection;
 249   TrackerSparqlCursor *cursor;
 250   GError *error = NULL;
 251
 252   tracker = GTK_SEARCH_ENGINE_TRACKER (user_data);
 253
 254   tracker->priv->query_pending = FALSE;
 255
 256   connection = TRACKER_SPARQL_CONNECTION (object);
 257         cursor = tracker_sparql_connection_query_finish (connection,
 258                                                          result,
 259                                                          &error);
 260
 261         g_debug ("Query returned cursor:%p", cursor);
 262
 263   if (error)
 264     {
 265       _gtk_search_engine_error (GTK_SEARCH_ENGINE (tracker), error->message);
 266       g_error_free (error);
 267       return;
 268     }
 269
 270   if (!cursor)
 271           {
 272                   _gtk_search_engine_finished (GTK_SEARCH_ENGINE (tracker));
 273                   return;
 274           }
 275
 276   cursor_next (tracker, cursor);
 277 }
 278
 279 static void
 280 sparql_append_string_literal (GString     *sparql,
 281                               const gchar *str)
 282 {
 283   gchar *s;
 284
 285   s = tracker_sparql_escape_string (str);
 286
 287   g_string_append_c (sparql, '"');
 288   g_string_append (sparql, s);
 289   g_string_append_c (sparql, '"');
 290
 291   g_free (s);
 292 }
 293
 294 static void
 295 gtk_search_engine_tracker_start (GtkSearchEngine *engine)
 296 {
 297   GtkSearchEngineTracker *tracker;
 298   gchar *search_text, *location_uri;
 299   GString *sparql;
 300
 301   tracker = GTK_SEARCH_ENGINE_TRACKER (engine);
 302
 303   if (tracker->priv->query_pending)
 304           {
 305                   g_debug ("Attempt to start a new search while one is pending, doing nothing");
 306                   return;
 307           }
 308
 309   if (tracker->priv->query == NULL)
 310           {
 311                   g_debug ("Attempt to start a new search with no GtkQuery, doing nothing");
 312                   return;
 313           }
 314
 315   search_text = _gtk_query_get_text (tracker->priv->query);
 316   location_uri = _gtk_query_get_location (tracker->priv->query);
 317
 318   g_debug ("Query starting, search criteria:'%s', location:'%s'", search_text, location_uri);
 319
 320 #ifdef FTS_MATCHING
 321   /* Using FTS: */
 322   sparql = g_string_new ("SELECT nie:url(?urn) "
 323                          "WHERE {"
 324                          "  ?urn a nfo:FileDataObject ;"
 325                          "  tracker:available true ; "
 326                          "  fts:match ");
 327   sparql_append_string_literal (sparql, search_text);
 328
 329   if (location_uri)
 330           {
 331                   g_string_append (sparql, " . FILTER (fn:starts-with(nie:url(?urn),");
 332                   sparql_append_string_literal (sparql, location_uri);
 333                   g_string_append (sparql, "))");
 334           }
 335
 336   g_string_append (sparql, " } ORDER BY DESC(fts:rank(?urn)) ASC(nie:url(?urn))");
 337 #else  /* FTS_MATCHING */
 338   /* Using filename matching: */
 339   sparql = g_string_new ("SELECT nie:url(?urn) "
 340                          "WHERE {"
 341                          "  ?urn a nfo:FileDataObject ;"
 342                          "    tracker:available true ."
 343                          "  FILTER (fn:contains(nfo:fileName(?urn),");
 344   sparql_append_string_literal (sparql, search_text);
 345
 346   g_string_append (sparql,
 347                    "))"
 348                    "} ORDER BY DESC(nie:url(?urn)) DESC(nfo:fileName(?urn))");
 349 #endif /* FTS_MATCHING */
 350
 351   tracker_sparql_connection_query_async (tracker->priv->connection,
 352                                          sparql->str,
 353                                          tracker->priv->cancellable,
 354                                          query_callback,
 355                                          tracker);
 356   g_string_free (sparql, TRUE);
 357
 358   tracker->priv->query_pending = TRUE;
 359   g_free (search_text);
 360 }
 361
 362 static void
 363 gtk_search_engine_tracker_stop (GtkSearchEngine *engine)
 364 {
 365   GtkSearchEngineTracker *tracker;
 366
 367   tracker = GTK_SEARCH_ENGINE_TRACKER (engine);
 368
 369   g_debug ("Query stopping");
 370
 371   if (tracker->priv->query && tracker->priv->query_pending)
 372     {
 373             g_cancellable_cancel (tracker->priv->cancellable);
 374       tracker->priv->query_pending = FALSE;
 375     }
 376 }
 377
 378 static gboolean
 379 gtk_search_engine_tracker_is_indexed (GtkSearchEngine *engine)
 380 {
 381   return TRUE;
 382 }
 383
 384 static void
 385 gtk_search_engine_tracker_set_query (GtkSearchEngine *engine,
 386                                      GtkQuery        *query)
 387 {
 388   GtkSearchEngineTracker *tracker;
 389
 390   tracker = GTK_SEARCH_ENGINE_TRACKER (engine);
 391
 392   if (query)
 393     g_object_ref (query);
 394
 395   if (tracker->priv->query)
 396     g_object_unref (tracker->priv->query);
 397
 398   tracker->priv->query = query;
 399 }
 400
 401 static void
 402 _gtk_search_engine_tracker_class_init (GtkSearchEngineTrackerClass *class)
 403 {
 404   GObjectClass *gobject_class;
 405   GtkSearchEngineClass *engine_class;
 406
 407   gobject_class = G_OBJECT_CLASS (class);
 408   gobject_class->finalize = finalize;
 409
 410   engine_class = GTK_SEARCH_ENGINE_CLASS (class);
 411   engine_class->set_query = gtk_search_engine_tracker_set_query;
 412   engine_class->start = gtk_search_engine_tracker_start;
 413   engine_class->stop = gtk_search_engine_tracker_stop;
 414   engine_class->is_indexed = gtk_search_engine_tracker_is_indexed;
 415
 416   g_type_class_add_private (gobject_class, sizeof (GtkSearchEngineTrackerPrivate));
 417 }
 418
 419 static void
 420 _gtk_search_engine_tracker_init (GtkSearchEngineTracker *engine)
 421 {
 422   engine->priv = G_TYPE_INSTANCE_GET_PRIVATE (engine,
 423                                               GTK_TYPE_SEARCH_ENGINE_TRACKER,
 424                                               GtkSearchEngineTrackerPrivate);
 425 }
 426
 427
 428 GtkSearchEngine *
 429 _gtk_search_engine_tracker_new (void)
 430 {
 431   GtkSearchEngineTracker *engine;
 432   TrackerSparqlConnection *connection;
 433   GCancellable *cancellable;
 434   GError *error = NULL;
 435
 436   if (!init ())
 437           return NULL;
 438
 439   g_debug ("Creating GtkSearchEngineTracker...");
 440
 441   cancellable = g_cancellable_new ();
 442         connection = tracker_sparql_connection_get (cancellable, &error);
 443
 444         if (error)
 445                 {
 446                         g_warning ("Could not establish a connection to Tracker: %s", error->message);
 447                         g_error_free (error);
 448                         return NULL;
 449                 }
 450         else if (!connection)
 451           {
 452                   g_warning ("Could not establish a connection to Tracker, no TrackerSparqlConnection was returned");
 453                   return NULL;
 454           }
 455
 456   engine = g_object_new (GTK_TYPE_SEARCH_ENGINE_TRACKER, NULL);
 457
 458   engine->priv->connection = connection;
 459   engine->priv->cancellable = cancellable;
 460   engine->priv->query_pending = FALSE;
 461
 462   return GTK_SEARCH_ENGINE (engine);
 463 }