Merge lp:~mhr3/unity-lens-music/rb-parse-tdb into lp:unity-lens-music

[Michal Hruby]

Added rhythmbox's TDB parsing so we'll have more sources of album arts in the lens

Added rhythmbox's TDB parsing so we'll have more sources of album arts in the lens.

[Gord Allott (gordallott)]

seems good to me, +1

review: Approve

[Unity Merger (unity-merger)]

No commit message specified.

[Unity Merger (unity-merger)]

The Jenkins job https://jenkins.qa.ubuntu.com/job/automerge-unity-lens-music/16/console reported an error when processing this lp:~mhr3/unity-lens-music/rb-parse-tdb branch.
Not merging it.

=== modified file 'configure.ac'
--- configure.ac	2012-04-12 07:57:42 +0000
+++ configure.ac	2012-04-23 12:39:24 +0000
@@ -64,7 +64,8 @@
                   sqlite3 >= 3.7.7
                   gee-1.0
 		  json-glib-1.0
-                  unity >= 4.99.0)
+                  unity >= 4.99.0
+                  tdb >= 1.2.6)
 
 AC_SUBST(LENS_DAEMON_CFLAGS)
 AC_SUBST(LENS_DAEMON_LIBS)
 
=== modified file 'src/Makefile.am'
--- src/Makefile.am	2012-03-27 21:51:45 +0000
+++ src/Makefile.am	2012-04-23 12:39:24 +0000
@@ -28,6 +28,9 @@
   --pkg gio-2.0 \
   --pkg gio-unix-2.0 \
   --pkg glib-2.0 \
+  --vapidir $(srcdir) \
+  --pkg tdb \
+  --target-glib=2.26 \
   $(MAINTAINER_VALAFLAGS)
 
 unity_music_daemon_LDADD = \
@@ -98,6 +101,8 @@
   unity_musicstore_daemon.vala.stamp \
   $(unity_music_daemon_VALASOURCES) \
   $(unity_musicstore_daemon_VALASOURCES) \
+  tdb.vapi \
+  tdb.deps \
   $(NULL)
 
 unity_music_daemon.vala.stamp: $(unity_music_daemon_VALASOURCES)
 
=== modified file 'src/daemon.vala'
--- src/daemon.vala	2012-03-20 14:59:27 +0000
+++ src/daemon.vala	2012-04-23 12:39:24 +0000
@@ -32,9 +32,6 @@
      
     construct
     {
-      banshee = new BansheeScopeProxy ();
-      rb = new RhythmboxScope ();
-
       lens = new Unity.Lens("/com/canonical/unity/lens/music", "music");
       lens.search_in_global = true;
       lens.search_hint = _("Search Music Collection");
@@ -44,8 +41,19 @@
       populate_categories ();
       populate_filters();
 
-      lens.add_local_scope (banshee.scope);
-      lens.add_local_scope (rb.scope);
+      var app_check = new DesktopAppInfo ("banshee.desktop");
+      if (app_check != null)
+      {
+        banshee = new BansheeScopeProxy ();
+        lens.add_local_scope (banshee.scope);
+      }
+
+      app_check = new DesktopAppInfo ("rhythmbox.desktop");
+      if (app_check != null)
+      {
+        rb = new RhythmboxScope ();
+        lens.add_local_scope (rb.scope);
+      }
 
       try {
         lens.export ();
 
=== modified file 'src/rhythmbox-collection.vala'
--- src/rhythmbox-collection.vala	2012-03-27 21:51:45 +0000
+++ src/rhythmbox-collection.vala	2012-04-23 12:39:24 +0000
@@ -45,14 +45,19 @@
     {
 
         SequenceModel all_tracks;
+        ModelTag<int> album_art_tag;
         FilterModel tracks_by_play_count;
 
+        TDB.Database album_art_tdb;
+        FileMonitor tdb_monitor;
+        int current_album_art_tag;
+
         HashTable<unowned string, Variant> variant_store;
         HashTable<int, Variant> int_variant_store;
         Variant row_buffer[11];
 
         Analyzer analyzer;
-        Index index;
+        Index? index;
         ICUTermFilter ascii_filter;
 
         string media_art_dir;
@@ -203,9 +208,10 @@
                                                            direct_equal);
           all_tracks = new SequenceModel ();
           // the columns correspond to the Columns enum
-          all_tracks.set_schema ("s", "s", "s", "s", "s", "s", "s", "s", "i", "i", "i");
+          all_tracks.set_schema ("s", "s", "s", "s", "s", "s",
+                                 "s", "s", "i", "i", "i");
           assert (all_tracks.get_schema ().length == Columns.N_COLUMNS);
-          
+          album_art_tag = new ModelTag<int> (all_tracks);
 
           var filter = Dee.Filter.new_sort ((row1, row2) =>
           {
@@ -227,6 +233,11 @@
               if (folded != term) terms_out.add_term (folded);
             }
           });
+          initialize_index ();
+        }
+
+        private void initialize_index ()
+        {
           var reader = ModelReader.new ((model, iter) =>
           {
             var s ="%s\n%s\n%s".printf (model.get_string (iter, Columns.TITLE),
@@ -237,21 +248,63 @@
 
           index = new TreeIndex (all_tracks, analyzer, reader);
         }
+
+        private string? check_album_art_tdb (string artist, string album)
+        {
+          if (album_art_tdb == null) return null;
+
+          uint8 null_helper[1] = { 0 };
+          ByteArray byte_arr = new ByteArray ();
+          byte_arr.append ("album".data);
+          byte_arr.append (null_helper);
+          byte_arr.append (album.data);
+          byte_arr.append (null_helper);
+          byte_arr.append ("artist".data);
+          byte_arr.append (null_helper);
+          byte_arr.append (artist.data);
+          byte_arr.append (null_helper);
+
+          TDB.Data key = TDB.NULL_DATA;
+          key.data = byte_arr.data;
+          var val = album_art_tdb.fetch (key);
+
+          if (val.data != null)
+          {
+            Variant v = Variant.new_from_data<int> (new VariantType ("a{sv}"), val.data, false);
+            var file_variant = v.lookup_value ("file", VariantType.STRING);
+            if (file_variant != null)
+            {
+              return file_variant.get_string ();
+            }
+          }
+
+          return null;
+        }
         
         private string? get_albumart (Track track)
         {
+            string filename;
             var artist = track.album_artist ?? track.artist;
             var album = track.album;
 
             var artist_norm = artist.normalize (-1, NormalizeMode.NFKD);
             var album_norm = album.normalize (-1, NormalizeMode.NFKD);
 
+            filename = check_album_art_tdb (artist, album);
+            if (filename != null)
+            {
+              filename = Path.build_filename (Environment.get_user_cache_dir (),
+                                              "rhythmbox", "album-art",
+                                              filename);
+
+              if (FileUtils.test (filename, FileTest.EXISTS)) return filename;
+            }
+
             var artist_md5 = Checksum.compute_for_string (ChecksumType.MD5,
                                                           artist_norm);
             var album_md5 = Checksum.compute_for_string (ChecksumType.MD5,
                                                          album_norm);
 
-            string filename;
             filename = Path.build_filename (media_art_dir,
                 "album-%s-%s".printf (artist_md5, album_md5));
             if (FileUtils.test (filename, FileTest.EXISTS)) return filename;
@@ -331,8 +384,59 @@
           row_buffer[10] = play_count;
         }
 
+        public void parse_metadata_file (string path)
+        {
+          if (album_art_tdb != null) return;
+
+          if (tdb_monitor == null)
+          {
+            var tdb_file = File.new_for_path (path);
+            try
+            {
+              tdb_monitor = tdb_file.monitor (FileMonitorFlags.NONE);
+              tdb_monitor.changed.connect (() =>
+              {
+                if (album_art_tdb == null) parse_metadata_file (path);
+                else current_album_art_tag++;
+              });
+            }
+            catch (Error err)
+            {
+              warning ("%s", err.message);
+            }
+          }
+
+          var flags = TDB.OpenFlags.INCOMPATIBLE_HASH | TDB.OpenFlags.SEQNUM | TDB.OpenFlags.NOLOCK;
+          album_art_tdb = new TDB.Database (path, 999, flags,
+                                            Posix.O_RDONLY, 0600);
+          if (album_art_tdb == null)
+          {
+            warning ("Unable to open album-art DB!");
+            return;
+          }
+
+          /*
+          album_art_tdb.traverse ((db, key, val) =>
+          {
+            var byte_arr = new ByteArray.sized ((uint) val.data_size);
+            byte_arr.append (val.data);
+            Variant v = Variant.new_from_data<ByteArray> (new VariantType ("a{sv}"), byte_arr.data, false, byte_arr);
+            message ("value: %s", v.print (true));
+
+            return 0;
+          });
+          */
+        }
+
         public void parse_file (string path)
         {
+          // this could be really expensive if the index was already built, so
+          // we'll destroy it first
+          index = null;
+          all_tracks.clear ();
+          initialize_index ();
+          current_album_art_tag = 0;
+
           var parser = new XmlParser ();
           parser.track_info_ready.connect ((track) =>
           {
@@ -366,6 +470,48 @@
           }
         }
 
+        private void add_result (Model results_model, Model model,
+                                 ModelIter iter, Columns title_col,
+                                 uint category_id)
+        {
+          // check for updated album art
+          var tag = album_art_tag[model, iter];
+          if (tag < current_album_art_tag)
+          {
+            unowned string album = model.get_string (iter, Columns.ALBUM);
+            unowned string artist = model.get_string (iter,
+                                                      Columns.ALBUM_ARTIST);
+            if (artist == "")
+              artist = model.get_string (iter, Columns.ARTIST);
+
+            var album_art_string = check_album_art_tdb (artist, album);
+            if (album_art_string != null)
+            {
+              string filename;
+              filename = Path.build_filename (Environment.get_user_cache_dir (),
+                                              "rhythmbox", "album-art",
+                                              album_art_string);
+              album_art_string = FileUtils.test (filename, FileTest.EXISTS) ?
+                filename : "audio-x-generic";
+
+              if (album_art_string != model.get_string (iter, Columns.ARTWORK))
+              {
+                model.set_value (iter, Columns.ARTWORK,
+                                 cached_variant_for_string (album_art_string));
+              }
+            }
+            album_art_tag[model, iter] = current_album_art_tag;
+          }
+
+          results_model.append (model.get_string (iter, Columns.URI),
+                                model.get_string (iter, Columns.ARTWORK),
+                                category_id,
+                                model.get_string (iter, Columns.MIMETYPE),
+                                model.get_string (iter, title_col),
+                                model.get_string (iter, Columns.ARTIST),
+                                model.get_string (iter, Columns.URI));
+        }
+
         public void search (LensSearch search, 
                             SearchType search_type, 
                             GLib.List<FilterParser>? filters = null,
@@ -420,28 +566,16 @@
                     {
                         category_id = category_override >= 0 ?
                             category_override : Category.ALBUMS;
-
-                        search.results_model.append (
-                            model.get_string (iter, Columns.URI),
-                            model.get_string (iter, Columns.ARTWORK),
-                            category_id,
-                            model.get_string (iter, Columns.MIMETYPE),
-                            model.get_string (iter, Columns.ALBUM),
-                            model.get_string (iter, Columns.ARTIST),
-                            model.get_string (iter, Columns.URI));
+                        
+                        add_result (search.results_model, model, iter,
+                                    Columns.ALBUM, category_id);
                     }
 
                     category_id = category_override >= 0 ?
                         category_override : Category.SONGS;
 
-                    search.results_model.append (
-                        model.get_string (iter, Columns.URI),
-                        model.get_string (iter, Columns.ARTWORK),
-                        category_id,
-                        model.get_string (iter, Columns.MIMETYPE),
-                        model.get_string (iter, Columns.TITLE),
-                        model.get_string (iter, Columns.ARTIST),
-                        model.get_string (iter, Columns.URI));
+                    add_result (search.results_model, model, iter,
+                                Columns.TITLE, category_id);
 
                     num_results++;
                     if (max_results >= 0 && num_results >= max_results) break;
@@ -515,6 +649,7 @@
 
                 unowned string album = model.get_string (model_iter,
                                                          Columns.ALBUM);
+
                 // it's not first as in track #1, but first found from album
                 bool first_track_from_album = !(album in albums_list);
                 albums_list.add (album);
@@ -524,27 +659,15 @@
                     category_id = category_override >= 0 ?
                         category_override : Category.ALBUMS;
 
-                    search.results_model.append (
-                        model.get_string (model_iter, Columns.URI),
-                        model.get_string (model_iter, Columns.ARTWORK),
-                        category_id,
-                        model.get_string (model_iter, Columns.MIMETYPE),
-                        model.get_string (model_iter, Columns.ALBUM),
-                        model.get_string (model_iter, Columns.ARTIST),
-                        model.get_string (model_iter, Columns.URI));
+                    add_result (search.results_model, model, model_iter,
+                                Columns.ALBUM, category_id);
                 }
 
                 category_id = category_override >= 0 ?
                     category_override : Category.SONGS;
 
-                search.results_model.append (
-                    model.get_string (model_iter, Columns.URI),
-                    model.get_string (model_iter, Columns.ARTWORK),
-                    category_id,
-                    model.get_string (model_iter, Columns.MIMETYPE),
-                    model.get_string (model_iter, Columns.TITLE),
-                    model.get_string (model_iter, Columns.ARTIST),
-                    model.get_string (model_iter, Columns.URI));
+                add_result (search.results_model, model, model_iter,
+                            Columns.TITLE, category_id);
 
                 num_results++;
                 if (max_results >= 0 && num_results >= max_results) break;
 
=== modified file 'src/rhythmbox-scope.vala'
--- src/rhythmbox-scope.vala	2012-03-20 14:59:27 +0000
+++ src/rhythmbox-scope.vala	2012-04-23 12:39:24 +0000
@@ -25,6 +25,7 @@
   { 
     private RhythmboxCollection collection;
     private bool db_ready;
+    private FileMonitor rb_xml_monitor;
 
     public RhythmboxScope ()
     {
@@ -105,7 +106,29 @@
       if (!db_ready)
       {
         // parse the DB lazily
-        collection.parse_file ("%s/.local/share/rhythmbox/rhythmdb.xml".printf (Environment.get_home_dir ()));
+        var tdb_path = Path.build_filename (Environment.get_user_cache_dir (),
+                                            "rhythmbox", "album-art",
+                                            "store.tdb");
+        collection.parse_metadata_file (tdb_path);
+
+        var xml_path = Path.build_filename (Environment.get_user_data_dir (),
+                                            "rhythmbox", "rhythmdb.xml");
+        collection.parse_file (xml_path);
+        if (rb_xml_monitor == null)
+        {
+          // re-parse the file if it changes
+          File xml_file = File.new_for_path (xml_path);
+          try
+          {
+            rb_xml_monitor = xml_file.monitor (FileMonitorFlags.NONE);
+            rb_xml_monitor.changed.connect (() => { db_ready = false; });
+          }
+          catch (Error err)
+          {
+            warning ("%s", err.message);
+          }
+        }
+
         db_ready = true;
       }
 
 
=== added file 'src/tdb.deps'
--- src/tdb.deps	1970-01-01 00:00:00 +0000
+++ src/tdb.deps	2012-04-23 12:39:24 +0000
@@ -0,0 +1,1 @@
+posix
 
=== added file 'src/tdb.vapi'
--- src/tdb.vapi	1970-01-01 00:00:00 +0000
+++ src/tdb.vapi	2012-04-23 12:39:24 +0000
@@ -0,0 +1,125 @@
+/* tdb.vapi
+ *
+ * Copyright (C) 2012 Canonical Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+ *
+ * Author:
+ * 	Michal Hruby <[e-mail]>
+ */
+
+[CCode (lower_case_cprefix = "tdb_", cheader_filename = "tdb.h")]
+namespace TDB {
+	/* Database Connection Handle */
+	[Compact]
+	[CCode (free_function = "tdb_close", cname = "TDB_CONTEXT", cprefix = "tdb_")]
+	public class Database {
+		[CCode (cname = "tdb_open")]
+		public Database (string name, int hash_size, TDB.OpenFlags tdb_flags, int open_flags, Posix.mode_t mode);
+		[CCode (cname = "tdb_open_ex")]
+		public Database.open_ex (string name, int hash_size, int tdb_flags, int open_flags, Posix.mode_t mode, TDB.LogFunc log_fn);
+
+		public int reopen ();
+		public static int reopen_all ();
+
+		public TDB.Error error ();
+		public unowned string errorstr ();
+
+		public TDB.Data fetch (TDB.Data key);
+		public int @delete (TDB.Data key);
+		public int store (TDB.Data key, TDB.Data dbuf, TDB.StoreType type_flag);
+		public TDB.Data firstkey ();
+		public TDB.Data nextkey (TDB.Data key);
+		public int traverse (TDB.TraverseFunc traverse_func);
+		public int exists (TDB.Data key);
+		public int lockkeys (TDB.Data[] keys);
+		public void unlockkeys ();
+		public int lockall ();
+		public void unlockall ();
+
+		public int chainlock (TDB.Data key);
+		public void chainunlock (TDB.Data key);
+	}
+
+	[CCode (cname = "TDB_DATA")]
+	[SimpleType]
+	public struct Data {
+		[CCode (array_length_cname = "dsize", array_length_type = "size_t", cname = "dptr")]
+		public unowned uint8[] data;
+		[CCode (cname = "dsize")]
+		public size_t data_size;
+	}
+
+	[CCode (cname = "tdb_null")]
+	public const TDB.Data NULL_DATA;
+
+	[CCode (has_target = false)]
+	public delegate void LogFunc (TDB.Database db, TDB.DebugLevel debug_level, string format, ...);
+
+	public delegate int TraverseFunc (TDB.Database db, TDB.Data key, TDB.Data @value);
+
+	[CCode (cname = "SQLITE_ANY")]
+	public const int ANY;
+
+	[CCode (cname = "enum tdb_debug_level", cprefix = "TDB_DEBUG_")]
+	public enum DebugLevel {
+		FATAL,
+		ERROR,
+		WARNING,
+		TRACE
+	}
+
+	[CCode (cname = "int", cprefix = "TDB_")]
+	public enum StoreType {
+		REPLACE,
+		INSERT,
+		MODIFY
+	}
+
+	[CCode (cname = "int", cprefix = "TDB_")]
+	public enum OpenFlags {
+		DEFAULT,
+		CLEAR_IF_FIRST,
+		INTERNAL,
+		NOLOCK,
+		NOMMAP,
+		CONVERT,
+		BIGENDIAN,
+		NOSYNC,
+		SEQNUM,
+		VOLATILE,
+		ALLOW_NESTING,
+		DISALLOW_NESTING,
+		INCOMPATIBLE_HASH
+	}
+
+	[CCode (cname = "enum TDB_ERROR", cprefix = "TDB_ERR_")]
+	public enum Error {
+		[CCode (cname = "TDB_SUCCESS")]
+		SUCCESS,
+		CORRUPT,
+		IO,
+		LOCK,
+		OOM,
+		EXISTS,
+		NOLOCK,
+		LOCK_TIMEOUT,
+		NOEXISTS,
+		EINVAL,
+		RDONLY,
+		NESTING
+	}
+}
+