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