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

   1 /*
   2  * Copyright (C) 2005 Jamie McCracken <jamiemcc@gnome.org>
   3  * Copyright (C) 2009-2010 Nokia <ivan.frade@nokia.com>
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  *
  19  * Authors: Jamie McCracken <jamiemcc@gnome.org>
  20  *          Jürg Billeter <juerg.billeter@codethink.co.uk>
  21  *          Martyn Russell <martyn@lanedo.com>
  22  *
  23  * Based on nautilus-search-engine-tracker.c
  24  */
  25
  26 #include "config.h"
  27 #include <gmodule.h>
  28 #include "gtksearchenginetracker.h"
  29
  30 /* we dlopen() libtracker at runtime */
  31
  32 typedef struct _TrackerClient TrackerClient;
  33
  34 typedef enum
  35 {
  36   TRACKER_UNAVAILABLE = 0,
  37   TRACKER_0_6 = 1 << 0,
  38   TRACKER_0_7 = 1 << 1,
  39   TRACKER_0_8 = 1 << 2,
  40   TRACKER_0_9 = 1 << 3
  41 } TrackerVersion;
  42
  43
  44 /* Tracker 0.6 API */
  45 typedef void (*TrackerArrayReply) (char **result,
  46                                    GError *error,
  47                                    gpointer user_data);
  48
  49 static TrackerClient *
  50             (*tracker_connect)                                    (gboolean           enable_warnings,
  51                                                                    gint               timeout)   = NULL;
  52 static void (*tracker_disconnect)                                 (TrackerClient     *client)    = NULL;
  53 static int  (*tracker_get_version)                                (TrackerClient     *client,
  54                                                                    GError           **error)     = NULL;
  55 static void (*tracker_cancel_last_call)                           (TrackerClient     *client)    = NULL;
  56
  57 static void (*tracker_search_metadata_by_text_async)              (TrackerClient     *client,
  58                                                                    const char        *query,
  59                                                                    TrackerArrayReply  callback,
  60                                                                    gpointer           user_data) = NULL;
  61 static void (*tracker_search_metadata_by_text_and_location_async) (TrackerClient     *client,
  62                                                                    const char        *query,
  63                                                                    const char        *location,
  64                                                                    TrackerArrayReply  callback,
  65                                                                    gpointer           user_data) = NULL;
  66
  67
  68 /* Tracker 0.7->0.9 API */
  69 typedef enum {
  70         TRACKER_CLIENT_ENABLE_WARNINGS = 1 << 0
  71 } TrackerClientFlags;
  72
  73 typedef void (*TrackerReplyGPtrArray) (GPtrArray *result,
  74                                        GError    *error,
  75                                        gpointer   user_data);
  76
  77 static TrackerClient *  (*tracker_client_new)                    (TrackerClientFlags      flags,
  78                                                                   gint                    timeout)   = NULL;
  79 static gchar *          (*tracker_sparql_escape)                 (const gchar            *str)       = NULL;
  80 static guint            (*tracker_resources_sparql_query_async)  (TrackerClient          *client,
  81                                                                   const gchar            *query,
  82                                                                   TrackerReplyGPtrArray   callback,
  83                                                                   gpointer                user_data) = NULL;
  84
  85
  86 static struct TrackerDlMapping
  87 {
  88   const char *fn_name;
  89   gpointer *fn_ptr_ref;
  90   TrackerVersion versions;
  91 } tracker_dl_mapping[] =
  92 {
  93 #define MAP(a,v) { #a, (gpointer *)&a, v }
  94   MAP (tracker_connect, TRACKER_0_6 | TRACKER_0_7),
  95   MAP (tracker_disconnect, TRACKER_0_6 | TRACKER_0_7),
  96   MAP (tracker_get_version, TRACKER_0_6),
  97   MAP (tracker_cancel_last_call, TRACKER_0_6 | TRACKER_0_7 | TRACKER_0_8 | TRACKER_0_9),
  98   MAP (tracker_search_metadata_by_text_async, TRACKER_0_6 | TRACKER_0_7),
  99   MAP (tracker_search_metadata_by_text_and_location_async, TRACKER_0_6 | TRACKER_0_7),
 100   MAP (tracker_client_new, TRACKER_0_8 | TRACKER_0_9),
 101   MAP (tracker_sparql_escape, TRACKER_0_8 | TRACKER_0_9),
 102   MAP (tracker_resources_sparql_query_async, TRACKER_0_8 | TRACKER_0_9)
 103 #undef MAP
 104 };
 105
 106 static TrackerVersion
 107 open_libtracker (void)
 108 {
 109   static gboolean done = FALSE;
 110   static TrackerVersion version = TRACKER_UNAVAILABLE;
 111   gpointer x;
 112
 113   if (!done)
 114     {
 115       gint i;
 116       GModule *tracker;
 117       GModuleFlags flags;
 118
 119       done = TRUE;
 120       flags = G_MODULE_BIND_LAZY | G_MODULE_BIND_LOCAL;
 121
 122       /* So this is the order:
 123        *
 124        * - 0.9 (latest unstable)
 125        * - 0.8 (stable)
 126        * - 0.7 (unstable, 0.6 sucks so badly)
 127        * - 0.6 (stable)
 128        */
 129       if ((tracker = g_module_open ("libtracker-client-0.9.so.0", flags)) != NULL)
 130         version = TRACKER_0_9;
 131       else if ((tracker = g_module_open ("libtracker-client-0.8.so.0", flags)) != NULL)
 132         version = TRACKER_0_8;
 133       else if ((tracker = g_module_open ("libtracker-client-0.7.so.0", flags)) != NULL)
 134         version = TRACKER_0_7;
 135       else if ((tracker = g_module_open ("libtrackerclient.so.0", flags)) != NULL)
 136         version = TRACKER_0_6;
 137       else
 138         {
 139           g_debug ("No tracker backend available");
 140           return TRACKER_UNAVAILABLE;
 141         }
 142
 143       for (i = 0; i < G_N_ELEMENTS (tracker_dl_mapping); i++)
 144         {
 145           if ((tracker_dl_mapping[i].versions & version) == 0)
 146             continue;
 147
 148           if (!g_module_symbol (tracker,
 149                                 tracker_dl_mapping[i].fn_name,
 150                                 tracker_dl_mapping[i].fn_ptr_ref))
 151             {
 152               g_warning ("Missing symbol '%s' in libtracker\n",
 153                          tracker_dl_mapping[i].fn_name);
 154               g_module_close (tracker);
 155
 156               for (i = 0; i < G_N_ELEMENTS (tracker_dl_mapping); i++)
 157                 tracker_dl_mapping[i].fn_ptr_ref = NULL;
 158
 159               return TRACKER_UNAVAILABLE;
 160             }
 161         }
 162     }
 163
 164   return version;
 165 }
 166
 167 struct _GtkSearchEngineTrackerPrivate
 168 {
 169   GtkQuery      *query;
 170   TrackerClient *client;
 171   gboolean       query_pending;
 172   TrackerVersion version;
 173 };
 174
 175 G_DEFINE_TYPE (GtkSearchEngineTracker, _gtk_search_engine_tracker, GTK_TYPE_SEARCH_ENGINE);
 176
 177
 178 static void
 179 finalize (GObject *object)
 180 {
 181   GtkSearchEngineTracker *tracker;
 182
 183   tracker = GTK_SEARCH_ENGINE_TRACKER (object);
 184
 185   if (tracker->priv->query)
 186     {
 187       g_object_unref (tracker->priv->query);
 188       tracker->priv->query = NULL;
 189     }
 190
 191   if (tracker->priv->version == TRACKER_0_8 ||
 192       tracker->priv->version == TRACKER_0_9)
 193     g_object_unref (tracker->priv->client);
 194   else
 195     tracker_disconnect (tracker->priv->client);
 196
 197   G_OBJECT_CLASS (_gtk_search_engine_tracker_parent_class)->finalize (object);
 198 }
 199
 200
 201 /* stolen from tracker sources, tracker.c */
 202 static void
 203 sparql_append_string_literal (GString     *sparql,
 204                               const gchar *str)
 205 {
 206   gchar *s;
 207
 208   s = tracker_sparql_escape (str);
 209
 210   g_string_append_c (sparql, '"');
 211   g_string_append (sparql, s);
 212   g_string_append_c (sparql, '"');
 213
 214   g_free (s);
 215 }
 216
 217
 218 static void
 219 search_callback (gpointer results,
 220                  GError  *error,
 221                  gpointer user_data)
 222 {
 223   GtkSearchEngineTracker *tracker;
 224   gchar **results_p;
 225   GList *hit_uris;
 226   GPtrArray *OUT_result;
 227   gchar *uri;
 228   gint i;
 229
 230   tracker = GTK_SEARCH_ENGINE_TRACKER (user_data);
 231   hit_uris = NULL;
 232
 233   tracker->priv->query_pending = FALSE;
 234
 235   if (error)
 236     {
 237       _gtk_search_engine_error (GTK_SEARCH_ENGINE (tracker), error->message);
 238       g_error_free (error);
 239       return;
 240     }
 241
 242   if (!results)
 243     return;
 244
 245   if (tracker->priv->version == TRACKER_0_8 ||
 246       tracker->priv->version == TRACKER_0_9)
 247     {
 248       OUT_result = (GPtrArray*) results;
 249
 250       for (i = 0; i < OUT_result->len; i++)
 251         {
 252           uri = g_strdup (((gchar **) OUT_result->pdata[i])[0]);
 253           if (uri)
 254             hit_uris = g_list_prepend (hit_uris, uri);
 255         }
 256
 257       g_ptr_array_foreach (OUT_result, (GFunc) g_free, NULL);
 258       g_ptr_array_free (OUT_result, TRUE);
 259     }
 260   else
 261     {
 262       for (results_p = results; *results_p; results_p++)
 263         {
 264           if (tracker->priv->version == TRACKER_0_6)
 265             uri = g_filename_to_uri (*results_p, NULL, NULL);
 266           else
 267             uri = g_strdup (*results_p);
 268
 269           if (uri)
 270             hit_uris = g_list_prepend (hit_uris, uri);
 271         }
 272       g_strfreev ((gchar **) results);
 273     }
 274
 275   _gtk_search_engine_hits_added (GTK_SEARCH_ENGINE (tracker), hit_uris);
 276   _gtk_search_engine_finished (GTK_SEARCH_ENGINE (tracker));
 277
 278   g_list_foreach (hit_uris, (GFunc) g_free, NULL);
 279   g_list_free (hit_uris);
 280 }
 281
 282
 283 static void
 284 gtk_search_engine_tracker_start (GtkSearchEngine *engine)
 285 {
 286   GtkSearchEngineTracker *tracker;
 287   gchar *search_text, *location, *location_uri;
 288   GString *sparql;
 289
 290   tracker = GTK_SEARCH_ENGINE_TRACKER (engine);
 291
 292   if (tracker->priv->query_pending)
 293     return;
 294
 295   if (tracker->priv->query == NULL)
 296     return;
 297
 298   search_text = _gtk_query_get_text (tracker->priv->query);
 299   location_uri = _gtk_query_get_location (tracker->priv->query);
 300
 301   location = NULL;
 302   if (location_uri)
 303     {
 304       if (tracker->priv->version == TRACKER_0_6)
 305         {
 306           location = g_filename_from_uri (location_uri, NULL, NULL);
 307           g_free (location_uri);
 308         }
 309       else
 310         location = location_uri;
 311     }
 312
 313   if (tracker->priv->version == TRACKER_0_8 ||
 314       tracker->priv->version == TRACKER_0_9)
 315     {
 316       sparql = g_string_new ("SELECT nie:url(?urn) WHERE { ?urn a nfo:FileDataObject; fts:match ");
 317       sparql_append_string_literal (sparql, search_text);
 318       if (location)
 319         {
 320           g_string_append (sparql, " . FILTER (fn:starts-with(nie:url(?urn),");
 321           sparql_append_string_literal (sparql, location);
 322           g_string_append (sparql, "))");
 323         }
 324       g_string_append (sparql, " } ORDER BY DESC(fts:rank(?urn)) ASC(nie:url(?urn))");
 325
 326       tracker_resources_sparql_query_async (tracker->priv->client,
 327                                             sparql->str,
 328                                             (TrackerReplyGPtrArray) search_callback,
 329                                             tracker);
 330       g_string_free (sparql, TRUE);
 331     }
 332   else
 333     {
 334       if (location)
 335         {
 336           tracker_search_metadata_by_text_and_location_async (tracker->priv->client,
 337                                                               search_text,
 338                                                               location,
 339                                                               (TrackerArrayReply) search_callback,
 340                                                               tracker);
 341         }
 342       else
 343         {
 344           tracker_search_metadata_by_text_async (tracker->priv->client,
 345                                                  search_text,
 346                                                  (TrackerArrayReply) search_callback,
 347                                                  tracker);
 348         }
 349     }
 350
 351   tracker->priv->query_pending = TRUE;
 352   g_free (search_text);
 353   g_free (location);
 354 }
 355
 356 static void
 357 gtk_search_engine_tracker_stop (GtkSearchEngine *engine)
 358 {
 359   GtkSearchEngineTracker *tracker;
 360
 361   tracker = GTK_SEARCH_ENGINE_TRACKER (engine);
 362
 363   if (tracker->priv->query && tracker->priv->query_pending)
 364     {
 365       tracker_cancel_last_call (tracker->priv->client);
 366       tracker->priv->query_pending = FALSE;
 367     }
 368 }
 369
 370 static gboolean
 371 gtk_search_engine_tracker_is_indexed (GtkSearchEngine *engine)
 372 {
 373   return TRUE;
 374 }
 375
 376 static void
 377 gtk_search_engine_tracker_set_query (GtkSearchEngine *engine,
 378                                      GtkQuery        *query)
 379 {
 380   GtkSearchEngineTracker *tracker;
 381
 382   tracker = GTK_SEARCH_ENGINE_TRACKER (engine);
 383
 384   if (query)
 385     g_object_ref (query);
 386
 387   if (tracker->priv->query)
 388     g_object_unref (tracker->priv->query);
 389
 390   tracker->priv->query = query;
 391 }
 392
 393 static void
 394 _gtk_search_engine_tracker_class_init (GtkSearchEngineTrackerClass *class)
 395 {
 396   GObjectClass *gobject_class;
 397   GtkSearchEngineClass *engine_class;
 398
 399   gobject_class = G_OBJECT_CLASS (class);
 400   gobject_class->finalize = finalize;
 401
 402   engine_class = GTK_SEARCH_ENGINE_CLASS (class);
 403   engine_class->set_query = gtk_search_engine_tracker_set_query;
 404   engine_class->start = gtk_search_engine_tracker_start;
 405   engine_class->stop = gtk_search_engine_tracker_stop;
 406   engine_class->is_indexed = gtk_search_engine_tracker_is_indexed;
 407
 408   g_type_class_add_private (gobject_class, sizeof (GtkSearchEngineTrackerPrivate));
 409 }
 410
 411 static void
 412 _gtk_search_engine_tracker_init (GtkSearchEngineTracker *engine)
 413 {
 414   engine->priv = G_TYPE_INSTANCE_GET_PRIVATE (engine, GTK_TYPE_SEARCH_ENGINE_TRACKER, GtkSearchEngineTrackerPrivate);
 415 }
 416
 417
 418 GtkSearchEngine *
 419 _gtk_search_engine_tracker_new (void)
 420 {
 421   GtkSearchEngineTracker *engine;
 422   TrackerClient *tracker_client;
 423   TrackerVersion version;
 424   GError *err = NULL;
 425
 426   version = open_libtracker ();
 427
 428   if (version == TRACKER_0_8 ||
 429       version == TRACKER_0_9)
 430     {
 431       tracker_client = tracker_client_new (TRACKER_CLIENT_ENABLE_WARNINGS, G_MAXINT);
 432     }
 433   else
 434     {
 435       if (!tracker_connect)
 436         return NULL;
 437
 438       tracker_client = tracker_connect (FALSE, -1);
 439     }
 440
 441   if (!tracker_client)
 442     return NULL;
 443
 444
 445   if (version == TRACKER_0_6)
 446     {
 447       if (!tracker_get_version)
 448         return NULL;
 449
 450       tracker_get_version (tracker_client, &err);
 451
 452       if (err != NULL)
 453         {
 454           g_error_free (err);
 455           tracker_disconnect (tracker_client);
 456           return NULL;
 457         }
 458     }
 459
 460   engine = g_object_new (GTK_TYPE_SEARCH_ENGINE_TRACKER, NULL);
 461
 462   engine->priv->client = tracker_client;
 463   engine->priv->query_pending = FALSE;
 464   engine->priv->version = version;
 465
 466   return GTK_SEARCH_ENGINE (engine);
 467 }