Merge lp:~gero-bare/noise/fix-1181327 into lp:~elementary-apps/noise/trunk

[Corentin Noël]

I'm implemented a blacklist system.
Basically you can add folders to being ignored,
or every file deleted can be blacklisted.

For now I want to hear some UX feedback.

[Viko Adi Rahmawan (vikoadi)]

Do we really need blacklisting here?
I thought removing song should just move it to trash (and it should be renamed as 'Move to Trash' or something)

[Gero.Bare (gero-bare)]

Sorry, first all I just word it badly.

The blacklist should be put in files removed from the library not deleted.

Second, I forgot to add the proper check.

Also I should notify the user that there are files/folders being omitted due to the blacklist.

[Corentin Noël (tintou)]

Synced with trunk here lp:~tintou/noise/fix-1181327

[Sam Hewitt (snwh)]

Blacklisting only would exempt files from the auto-import process. The "blacklist" is in the event of unwanted items being auto-imported.

All the "blacklist" is, is the list any and all files that a user has manually removed from his/her library.

I.e. when a user hits "Remove from Library" on an item in their Library, it's added to the blacklist (along with being removed) and to remove said item from the blacklist all they needs to do is re-import it from the gear menu.

Also, this shouldn't require any new user interface elements.

[Gero.Bare (gero-bare)]

@snwm
So you want to blacklist files so they won't be added again in background re-scans, but when you fully re-import all the library remove them from blacklist? Is that correct?

[Zisu Andrei (matzipan)]

Hey Gero,

I think if you re-import the entire library, the blacklist in that library should still be applicable.

The only time when a blacklist item is remove is when it is _directly_ added imported.

Unmerged revisions

2004. By Gero.Bare on 2016-11-15

Fixed some style isues.
Now the user will see listed paths instead of uris because is more intuitive, the backend are uris, but it transparent to the user.

2003. By Gero.Bare on 2016-11-11

Add blacklist system

=== modified file 'core/Settings.vala'
--- core/Settings.vala	2015-10-14 20:56:51 +0000
+++ core/Settings.vala	2016-11-15 06:21:53 +0000
@@ -65,6 +65,7 @@
         public bool update_folder_hierarchy { get; set; }
         public bool write_metadata_to_file { get; set; }
         public bool copy_imported_music { get; set; }
+        public bool blacklist_on_removal { get; set; }
         public bool close_while_playing { get; set; }
         public int64 last_media_playing { get; set; }
         public string last_playlist_playing { get; set; }

=== modified file 'schemas/org.pantheon.noise.gschema.xml'
--- schemas/org.pantheon.noise.gschema.xml	2015-08-24 16:05:21 +0000
+++ schemas/org.pantheon.noise.gschema.xml	2016-11-15 06:21:53 +0000
@@ -41,6 +41,11 @@
       <summary>Whether or not to copy imported files to music folder</summary>
       <description>Whether or not to copy imported files to music folder</description>
     </key>
+    <key type="b" name="blacklist-on-removal">
+      <default>false</default>
+      <summary>Whether or not to blacklist files on removal from the library</summary>
+      <description>Whether or not to blacklist files on removal from the library</description>
+    </key>
     <key type="b" name="close-while-playing">
       <default>false</default>
       <summary>Whether to close the player's window instead of hiding/minimizing it when a song is still playing. The window can be brought back by activating its desktop file.</summary>

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2016-02-08 16:56:22 +0000
+++ src/CMakeLists.txt	2016-11-15 06:21:53 +0000
@@ -66,6 +66,7 @@
     Dialogs/SetMusicFolderConfirmation.vala
     Dialogs/TransferFromDeviceDialog.vala
     Dialogs/SyncWarningDialog.vala
+    Dialogs/ManageBlackList.vala
 )
 
 set (CLIENT_VALAC_OPTIONS

=== modified file 'src/DataBase.vala'
--- src/DataBase.vala	2016-09-29 14:43:39 +0000
+++ src/DataBase.vala	2016-11-15 06:21:53 +0000
@@ -97,6 +97,11 @@
         public const string COLUMNS = "+3";
     }
 
+    namespace Blacklists {
+        public const string TABLE_NAME = "blacklists";
+        public const string URI = "+0";
+    }
+
     public static GLib.Value? query_field (int64 rowid, Gda.Connection connection, string table, string field) {
         try {
             var sql = new Gda.SqlBuilder (Gda.SqlStatementType.SELECT);
@@ -362,5 +367,23 @@
                 }
             }
         }
+
+        /*
+         * Creating the blacklist of items
+         */
+        operation = Gda.ServerOperation.prepare_create_table (connection, "blacklists", e,
+                                                                      "uri", typeof (string), Gda.ServerOperationCreateTableFlag.UNIQUE_FLAG);
+        if (e != null) {
+            critical (e.message);
+        } else {
+            try {
+                operation.perform_create_table ();
+            } catch (Error e) {
+                // e.code == 1 is when the table already exists.
+                if (e.code != 1) {
+                    critical (e.message);
+                }
+            }
+        }
     }
 }

=== added file 'src/Dialogs/ManageBlackList.vala'
--- src/Dialogs/ManageBlackList.vala	1970-01-01 00:00:00 +0000
+++ src/Dialogs/ManageBlackList.vala	2016-11-15 06:21:53 +0000
@@ -0,0 +1,178 @@
+// -*- Mode: vala; indent-tabs-mode: nil; tab-width: 4 -*-
+/*-
+ * Copyright (c) 2015 Noise Developers (http://launchpad.net/noise)
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * The Noise authors hereby grant permission for non-GPL compatible
+ * GStreamer plugins to be used and distributed together with GStreamer
+ * and Noise. This permission is above and beyond the permissions granted
+ * by the GPL license by which Noise is covered. If you modify this code
+ * you may extend this exception to your version of the code, but you are not
+ * obligated to do so. If you do not wish to do so, delete this exception
+ * statement from your version.
+ * Authored by: Geronimo Bareiro <[e-mail]>
+ */
+
+public class Noise.ManageBlackList : Gtk.Dialog {
+    public const int MIN_WIDTH = 420;
+    public const int MIN_HEIGHT = 300;
+
+    private Gtk.TreeView tree_view;
+    private Gtk.ListStore liststore;
+
+    private Gtk.Button add_folder_button;
+    private Gtk.Button remove_button;
+    private Gtk.Button close_button;
+
+    private Noise.LocalLibrary library_manager { get { return (Noise.LocalLibrary) libraries_manager.local_library; } }
+
+    public ManageBlackList () {}
+
+    construct {
+        title = _("Blacklisted Items");
+        set_size_request (MIN_WIDTH, MIN_HEIGHT);
+        resizable = false;
+        deletable = false;
+        destroy_with_parent = true;
+        window_position = Gtk.WindowPosition.CENTER;
+        set_transient_for (App.main_window);
+
+        add_folder_button = new Gtk.Button.with_label (_("Add Folders"));
+
+        remove_button = new Gtk.Button.with_label (_("Remove"));
+        remove_button.sensitive = false;
+
+        liststore = new Gtk.ListStore (1, typeof (string));
+
+        tree_view = new Gtk.TreeView ();
+        tree_view.set_model (liststore);
+        tree_view.hexpand = true;
+        tree_view.headers_visible = false;        
+        tree_view.insert_column_with_data_func (-1, "", new Gtk.CellRendererText (), (column, cell, model, iter) => {
+            string uri;
+            model.get(iter, 0, out uri);
+            try {
+                (cell as Gtk.CellRendererText).text = GLib.Filename.from_uri (uri);
+            } catch (Error e) {
+                warning (e.message);
+                (cell as Gtk.CellRendererText).text = uri;
+            }
+        });
+        tree_view.get_selection ().set_mode (Gtk.SelectionMode.MULTIPLE);
+
+        var scrolled_window = new Gtk.ScrolledWindow (null, null);
+        scrolled_window.set_policy (Gtk.PolicyType.AUTOMATIC , Gtk.PolicyType.AUTOMATIC);
+        scrolled_window.add (tree_view);
+        scrolled_window.set_min_content_height (MIN_HEIGHT - 50);
+
+        var list_grid = new Gtk.Grid ();
+        list_grid.attach (scrolled_window, 0, 0, 3, 3);
+        list_grid.attach (add_folder_button, 1, 3, 1, 1);
+        list_grid.attach (remove_button, 2, 3, 1, 1);
+
+        close_button = new Gtk.Button.with_label (_("Close"));
+
+        var button_box = new Gtk.ButtonBox (Gtk.Orientation.HORIZONTAL);
+        button_box.set_layout (Gtk.ButtonBoxStyle.END);
+        button_box.pack_end (close_button);
+        button_box.margin_right = 12;
+        button_box.margin_top = 12;
+
+        Gtk.Grid main_grid = new Gtk.Grid ();
+        main_grid.attach (list_grid, 0, 0, 4, 4);
+        main_grid.attach (button_box, 3, 4, 1, 1);
+
+        ((Gtk.Container) get_content_area ()).add (main_grid);
+
+        load_blacklist ();
+        connect_signals ();
+    }
+
+    private void load_blacklist () {
+        debug ("Loading blacklist");
+        liststore.clear ();
+        var black_list = library_manager.get_blacklist ();
+        foreach (string uri in black_list) {
+            debug ("Uri: %s", uri);
+            Gtk.TreeIter iter;
+            liststore.append (out iter);
+            liststore.set (iter, 0, uri);
+        }
+    }
+
+    private void connect_signals () {
+        close_button.clicked.connect (() => { destroy ();});
+
+        add_folder_button.clicked.connect (on_add);
+
+        remove_button.clicked.connect (on_remove);
+
+        tree_view.get_selection ().changed.connect (on_selection_changed);
+    }
+
+    private void on_selection_changed () {
+        if (tree_view.get_selection ().count_selected_rows () > 1) {
+            remove_button.sensitive = true;
+        } else {
+            remove_button.sensitive = true;
+        }
+
+    }
+
+    private void on_add () {
+        debug ("Adding folders to blacklist");
+
+        var file_chooser = new Gtk.FileChooserDialog (_("Folders to blacklist"), this,
+                                      Gtk.FileChooserAction.SELECT_FOLDER,
+                                      _("Cancel"), Gtk.ResponseType.CANCEL,
+                                      _("Open"), Gtk.ResponseType.ACCEPT);
+        file_chooser.set_select_multiple (true);
+        file_chooser.set_local_only (true);
+        if (file_chooser.run () == Gtk.ResponseType.ACCEPT) {
+            foreach (var folder in file_chooser.get_files ()) {
+                library_manager.blacklist_uri (folder.get_uri ());
+            }
+        }
+
+        file_chooser.destroy ();
+
+        // Reload after we finished.
+        load_blacklist ();
+    }
+
+    private void on_remove () {
+        debug ("BlactList on_remove");
+        List<Gtk.TreeIter?> items_to_remove = new List<Gtk.TreeIter?>();
+        var list = tree_view.get_selection ().get_selected_rows (null);
+        debug ("List lenght %u", list.length ());
+
+        foreach (unowned Gtk.TreePath element in list) {
+            Gtk.TreeIter iter;
+            if (liststore.get_iter (out iter, element)) {
+                GLib.Value uri;
+                liststore.get_value (iter, 0, out uri);
+                debug ("Appending uri to remove: %s", (string)uri);
+                library_manager.unblacklist_uri ((string)uri);
+                items_to_remove.append (iter);
+            }
+        }
+
+        foreach (var element in items_to_remove) {
+            liststore.remove (element);
+        }
+    }
+}

=== modified file 'src/Dialogs/PreferencesWindow.vala'
--- src/Dialogs/PreferencesWindow.vala	2015-12-19 14:41:06 +0000
+++ src/Dialogs/PreferencesWindow.vala	2016-11-15 06:21:53 +0000
@@ -124,6 +124,8 @@
     private Gtk.Switch write_file_metadata_switch;
     private Gtk.Switch copy_imported_music_switch;
     private Gtk.Switch hide_on_close_switch;
+    private Gtk.Switch blacklist_on_removal_switch;
+    private Gtk.Button manage_blacklist_button;
     public Noise.SettingsWindow.NoteBook_Page page;
 
     public GeneralPage (Gtk.FileChooserButton library_filechooser) {
@@ -158,7 +160,19 @@
         copy_imported_music_switch = new Gtk.Switch ();
         main_settings.schema.bind("copy-imported-music", copy_imported_music_switch, "active", SettingsBindFlags.DEFAULT);
         page.add_option (new Gtk.Label (_("Copy imported files to Library:")), copy_imported_music_switch, ref row);
-        
+
+        blacklist_on_removal_switch = new Gtk.Switch ();
+        main_settings.schema.bind("blacklist-on-removal", blacklist_on_removal_switch, "active", SettingsBindFlags.DEFAULT);
+        page.add_option (new Gtk.Label (_("Blacklist files on removal:")), blacklist_on_removal_switch, ref row);
+
+        manage_blacklist_button = new Gtk.Button.with_label (_("Manage"));
+        manage_blacklist_button.clicked.connect (() => {
+            var dialog = new Noise.ManageBlackList ();
+            dialog.show_all ();
+            dialog.run();
+        });
+        page.add_option (new Gtk.Label (_("Blacklisted items:")), manage_blacklist_button, ref row);
+
         label = new Gtk.Label (_("Desktop Integration"));
         page.add_section (label, ref row);
 

=== modified file 'src/LocalBackend/LocalLibrary.vala'
--- src/LocalBackend/LocalLibrary.vala	2016-09-29 15:00:27 +0000
+++ src/LocalBackend/LocalLibrary.vala	2016-11-15 06:21:53 +0000
@@ -44,6 +44,7 @@
     private Gee.HashMap<int64?, Media> _medias;
     private Gee.TreeSet<Media> _searched_medias;
     private Gee.HashMap<uint, Album> album_info;
+    private Gee.TreeSet<string> _blacklisted_uris;
 
     public StaticPlaylist p_music;
 
@@ -114,6 +115,9 @@
             var p = new LocalStaticPlaylist (p_id, connection);
             _playlists.add (p);
         }
+
+        //Load all blacklisted items from database
+        _blacklisted_uris = get_blacklisted_uris_from_database ();
     }
 
     /*
@@ -229,11 +233,27 @@
 
     private async void add_folder_to_library_async (Gee.Collection<string> folders) {
         var files = new Gee.TreeSet<string> ();
+
+        // We Transform uris to paths
+        var paths_blacklisted = new Gee.ArrayList<string> ();
+        foreach (var item in _blacklisted_uris) {
+            try {
+                paths_blacklisted.add (GLib.Filename.from_uri (item));
+            } catch (Error e) {
+                warning (e.message);
+            }
+        }
+        // We exclude blacklisted paths
+        folders.remove_all_array (paths_blacklisted.to_array ());
+
         foreach (var folder in folders) {
             var file = File.new_for_path (folder);
             FileUtils.count_music_files (file, files);
         }
 
+        // We exclude blacklisted files
+        files.remove_all_array (_blacklisted_uris.to_array ());
+
         foreach (var m in get_medias ()) {
             if (files.contains (m.uri))
                 files.remove (m.uri);
@@ -820,6 +840,10 @@
         foreach (var m in toRemove) {
             try {
                 connection.delete_row_from_table (Database.Media.TABLE_NAME, "rowid", m.rowid);
+                if (Settings.Main.get_default ().blacklist_on_removal && !trash) {
+                    blacklist_uri (m.uri);
+                }
+
             } catch (Error e) {
                 critical (e.message);
             }
@@ -878,6 +902,35 @@
         }
     }
 
+    public void blacklist_uri (string uri) {
+        if (_blacklisted_uris.contains (uri)) {
+            return;
+        }
+
+        try {
+            var builder = new Gda.SqlBuilder (Gda.SqlStatementType.INSERT);
+            builder.set_table (Database.Blacklists.TABLE_NAME);
+            builder.add_field_value_as_gvalue ("uri", uri);
+            connection.statement_execute_non_select (builder.get_statement (), null, null);
+            _blacklisted_uris.add (uri);
+        } catch (Error e) {
+            critical (e.message);
+        }
+    }
+
+    public void unblacklist_uri (string uri) {
+        try {
+            connection.delete_row_from_table (Database.Blacklists.TABLE_NAME, "uri", uri);
+            _blacklisted_uris.remove (uri);
+        } catch (Error e) {
+            critical (e.message);
+        }
+    }
+
+    public string[] get_blacklist () {
+        return _blacklisted_uris.to_array ();
+    }
+
     private Gee.Collection<int64?> get_rowids_from_table (string table_name) {
         var ids = new Gee.TreeSet<int64?> ();
         try {
@@ -896,4 +949,23 @@
 
         return ids;
     }
+
+    private Gee.TreeSet<string> get_blacklisted_uris_from_database () {
+        var blacklisted_uris = new Gee.TreeSet<string> ();
+        try {
+            var builder = new Gda.SqlBuilder (Gda.SqlStatementType.SELECT);
+            builder.select_add_target (Database.Blacklists.TABLE_NAME, null);
+            builder.select_add_field ("uri", null, null);
+            var data_model = connection.statement_execute_select (builder.get_statement (), null);
+            for (int i = 0; i < data_model.get_n_rows (); i++) {
+                var uri = data_model.get_value_at (data_model.get_column_index ("uri"), i);
+                blacklisted_uris.add (uri.dup_string ());
+            }
+        } catch (Error e) {
+            // TODO: Expose errors to the user !
+            critical ("Could not query table %s : %s", Database.Blacklists.TABLE_NAME, e.message);
+        }
+
+        return blacklisted_uris;
+    }
 }