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   gdk_threads_enter ();
 207
 208   tracker = GTK_SEARCH_ENGINE_TRACKER (user_data);
 209
 210         cursor = TRACKER_SPARQL_CURSOR (object);
 211         success = tracker_sparql_cursor_next_finish (cursor, result, &error);
 212
 213   if (error)
 214     {
 215       _gtk_search_engine_error (GTK_SEARCH_ENGINE (tracker), error->message);
 216
 217       g_error_free (error);
 218
 219       if (cursor)
 220               g_object_unref (cursor);
 221
 222       gdk_threads_leave ();
 223       return;
 224     }
 225
 226   if (!success)
 227           {
 228                   _gtk_search_engine_finished (GTK_SEARCH_ENGINE (tracker));
 229
 230                   if (cursor)
 231                           g_object_unref (cursor);
 232
 233                   gdk_threads_leave ();
 234                   return;
 235           }
 236
 237   /* We iterate result by result, not n at a time. */
 238   hits = g_list_append (NULL, (gchar*) tracker_sparql_cursor_get_string (cursor, 0, NULL));
 239   _gtk_search_engine_hits_added (GTK_SEARCH_ENGINE (tracker), hits);
 240   g_list_free (hits);
 241
 242   /* Get next */
 243   cursor_next (tracker, cursor);
 244
 245   gdk_threads_leave ();
 246
 247 }
 248
 249 static void
 250 query_callback (GObject      *object,
 251                 GAsyncResult *result,
 252                 gpointer      user_data)
 253 {
 254   GtkSearchEngineTracker *tracker;
 255   TrackerSparqlConnection *connection;
 256   TrackerSparqlCursor *cursor;
 257   GError *error = NULL;
 258
 259   gdk_threads_enter ();
 260
 261   tracker = GTK_SEARCH_ENGINE_TRACKER (user_data);
 262
 263   tracker->priv->query_pending = FALSE;
 264
 265   connection = TRACKER_SPARQL_CONNECTION (object);
 266         cursor = tracker_sparql_connection_query_finish (connection,
 267                                                          result,
 268                                                          &error);
 269
 270         g_debug ("Query returned cursor:%p", cursor);
 271
 272   if (error)
 273     {
 274       _gtk_search_engine_error (GTK_SEARCH_ENGINE (tracker), error->message);
 275       g_error_free (error);
 276       gdk_threads_leave ();
 277       return;
 278     }
 279
 280   if (!cursor)
 281           {
 282                   _gtk_search_engine_finished (GTK_SEARCH_ENGINE (tracker));
 283                   gdk_threads_leave ();
 284                   return;
 285           }
 286
 287   cursor_next (tracker, cursor);
 288   gdk_threads_leave ();
 289 }
 290
 291 static void
 292 sparql_append_string_literal (GString     *sparql,
 293                               const gchar *str)
 294 {
 295   gchar *s;
 296
 297   s = tracker_sparql_escape_string (str);
 298
 299   g_string_append_c (sparql, '"');
 300   g_string_append (sparql, s);
 301   g_string_append_c (sparql, '"');
 302
 303   g_free (s);
 304 }
 305
 306 static void
 307 gtk_search_engine_tracker_start (GtkSearchEngine *engine)
 308 {
 309   GtkSearchEngineTracker *tracker;
 310   gchar *search_text, *location_uri;
 311   GString *sparql;
 312
 313   tracker = GTK_SEARCH_ENGINE_TRACKER (engine);
 314
 315   if (tracker->priv->query_pending)
 316           {
 317                   g_debug ("Attempt to start a new search while one is pending, doing nothing");
 318                   return;
 319           }
 320
 321   if (tracker->priv->query == NULL)
 322           {
 323                   g_debug ("Attempt to start a new search with no GtkQuery, doing nothing");
 324                   return;
 325           }
 326
 327   search_text = _gtk_query_get_text (tracker->priv->query);
 328   location_uri = _gtk_query_get_location (tracker->priv->query);
 329
 330   g_debug ("Query starting, search criteria:'%s', location:'%s'", search_text, location_uri);
 331
 332 #ifdef FTS_MATCHING
 333   /* Using FTS: */
 334   sparql = g_string_new ("SELECT nie:url(?urn) "
 335                          "WHERE {"
 336                          "  ?urn a nfo:FileDataObject ;"
 337                          "  tracker:available true ; "
 338                          "  fts:match ");
 339   sparql_append_string_literal (sparql, search_text);
 340
 341   if (location_uri)
 342           {
 343                   g_string_append (sparql, " . FILTER (fn:starts-with(nie:url(?urn),");
 344                   sparql_append_string_literal (sparql, location_uri);
 345                   g_string_append (sparql, "))");
 346           }
 347
 348   g_string_append (sparql, " } ORDER BY DESC(fts:rank(?urn)) ASC(nie:url(?urn))");
 349 #else  /* FTS_MATCHING */
 350   /* Using filename matching: */
 351   sparql = g_string_new ("SELECT nie:url(?urn) "
 352                          "WHERE {"
 353                          "  ?urn a nfo:FileDataObject ;"
 354                          "    tracker:available true ."
 355                          "  FILTER (fn:contains(nfo:fileName(?urn),");
 356   sparql_append_string_literal (sparql, search_text);
 357
 358   g_string_append (sparql,
 359                    "))"
 360                    "} ORDER BY DESC(nie:url(?urn)) DESC(nfo:fileName(?urn))");
 361 #endif /* FTS_MATCHING */
 362
 363   tracker_sparql_connection_query_async (tracker->priv->connection,
 364                                          sparql->str,
 365                                          tracker->priv->cancellable,
 366                                          query_callback,
 367                                          tracker);
 368   g_string_free (sparql, TRUE);
 369
 370   tracker->priv->query_pending = TRUE;
 371   g_free (search_text);
 372 }
 373
 374 static void
 375 gtk_search_engine_tracker_stop (GtkSearchEngine *engine)
 376 {
 377   GtkSearchEngineTracker *tracker;
 378
 379   tracker = GTK_SEARCH_ENGINE_TRACKER (engine);
 380
 381   g_debug ("Query stopping");
 382
 383   if (tracker->priv->query && tracker->priv->query_pending)
 384     {
 385             g_cancellable_cancel (tracker->priv->cancellable);
 386       tracker->priv->query_pending = FALSE;
 387     }
 388 }
 389
 390 static gboolean
 391 gtk_search_engine_tracker_is_indexed (GtkSearchEngine *engine)
 392 {
 393   return TRUE;
 394 }
 395
 396 static void
 397 gtk_search_engine_tracker_set_query (GtkSearchEngine *engine,
 398                                      GtkQuery        *query)
 399 {
 400   GtkSearchEngineTracker *tracker;
 401
 402   tracker = GTK_SEARCH_ENGINE_TRACKER (engine);
 403
 404   if (query)
 405     g_object_ref (query);
 406
 407   if (tracker->priv->query)
 408     g_object_unref (tracker->priv->query);
 409
 410   tracker->priv->query = query;
 411 }
 412
 413 static void
 414 _gtk_search_engine_tracker_class_init (GtkSearchEngineTrackerClass *class)
 415 {
 416   GObjectClass *gobject_class;
 417   GtkSearchEngineClass *engine_class;
 418
 419   gobject_class = G_OBJECT_CLASS (class);
 420   gobject_class->finalize = finalize;
 421
 422   engine_class = GTK_SEARCH_ENGINE_CLASS (class);
 423   engine_class->set_query = gtk_search_engine_tracker_set_query;
 424   engine_class->start = gtk_search_engine_tracker_start;
 425   engine_class->stop = gtk_search_engine_tracker_stop;
 426   engine_class->is_indexed = gtk_search_engine_tracker_is_indexed;
 427
 428   g_type_class_add_private (gobject_class, sizeof (GtkSearchEngineTrackerPrivate));
 429 }
 430
 431 static void
 432 _gtk_search_engine_tracker_init (GtkSearchEngineTracker *engine)
 433 {
 434   engine->priv = G_TYPE_INSTANCE_GET_PRIVATE (engine,
 435                                               GTK_TYPE_SEARCH_ENGINE_TRACKER,
 436                                               GtkSearchEngineTrackerPrivate);
 437 }
 438
 439
 440 GtkSearchEngine *
 441 _gtk_search_engine_tracker_new (void)
 442 {
 443   GtkSearchEngineTracker *engine;
 444   TrackerSparqlConnection *connection;
 445   GCancellable *cancellable;
 446   GError *error = NULL;
 447
 448   if (!init ())
 449           return NULL;
 450
 451   g_debug ("Creating GtkSearchEngineTracker...");
 452
 453   cancellable = g_cancellable_new ();
 454         connection = tracker_sparql_connection_get (cancellable, &error);
 455
 456         if (error)
 457                 {
 458                         g_warning ("Could not establish a connection to Tracker: %s", error->message);
 459                         g_error_free (error);
 460                         return NULL;
 461                 }
 462         else if (!connection)
 463           {
 464                   g_warning ("Could not establish a connection to Tracker, no TrackerSparqlConnection was returned");
 465                   return NULL;
 466           }
 467
 468   engine = g_object_new (GTK_TYPE_SEARCH_ENGINE_TRACKER, NULL);
 469
 470   engine->priv->connection = connection;
 471   engine->priv->cancellable = cancellable;
 472   engine->priv->query_pending = FALSE;
 473
 474   return GTK_SEARCH_ENGINE (engine);
 475 }