[gnome-games/wip/aplazas/781334-refactor-playstation: 4/4] playstation: Make game creation more flexible

[Adrien Plazas <aplazas src gnome org>]

commit e90e05827d7d49ffb7323b343878effdf7093308
Author: Adrien Plazas <kekun plazas laposte net>
Date:   Fri Apr 14 15:48:04 2017 +0200

    playstation: Make game creation more flexible

 .../playstation/src/playstation-game-factory.vala  |  156 ++++++++------------
 1 files changed, 61 insertions(+), 95 deletions(-)
---
diff --git a/plugins/playstation/src/playstation-game-factory.vala 
b/plugins/playstation/src/playstation-game-factory.vala
index 489739b..3f8a0e2 100644
--- a/plugins/playstation/src/playstation-game-factory.vala
+++ b/plugins/playstation/src/playstation-game-factory.vala
@@ -9,15 +9,15 @@ public class Games.PlayStationGameFactory : Object, UriGameFactory {
 
        private static GameinfoDoc gameinfo;
 
-       private HashTable<string, string> discs;
-       private HashTable<string, GenericSet<string>> disc_sets;
-       private HashTable<string, Game> games;
+       private HashTable<string, Media> media_for_disc_id;
+       private HashTable<string, Game> game_for_uri;
+       private HashTable<string, Game> game_for_disc_set_id;
 
 
        public PlayStationGameFactory () {
-               discs = new HashTable<string, string> (GLib.str_hash, GLib.str_equal);
-               disc_sets = new HashTable<string, GenericSet<string>> (GLib.str_hash, GLib.str_equal);
-               games = new HashTable<string, Game> (GLib.str_hash, GLib.str_equal);
+               media_for_disc_id = new HashTable<string, Media> (str_hash, str_equal);
+               game_for_uri = new HashTable<string, Game> (GLib.str_hash, GLib.str_equal);
+               game_for_disc_set_id = new HashTable<string, Game> (GLib.str_hash, GLib.str_equal);
        }
 
        public string[] get_mime_types () {
@@ -28,130 +28,96 @@ public class Games.PlayStationGameFactory : Object, UriGameFactory {
                Idle.add (this.query_game_for_uri.callback);
                yield;
 
-               // TODO
+               if (game_for_uri.contains (uri))
+                       return game_for_uri[uri];
 
                return null;
        }
 
        public async void add_uri (string uri) {
-               string disc_id;
-
                try {
-                       disc_id = get_disc_id (uri);
+                       add_uri_with_error (uri);
                }
                catch (Error e) {
-                       return;
+                       debug (e.message);
                }
-
-               discs[disc_id] = uri;
        }
 
-       public async void foreach_game (GameCallback game_callback) {
-               GameinfoDoc gameinfo = null;
-               try {
-                       gameinfo = get_gameinfo ();
-               }
-               catch (Error e) {
-                       warning (e.message);
-               }
+       // TODO support unknown games (not in DB)
+       private void add_uri_with_error (string uri) throws Error {
+               if (game_for_uri.contains (uri))
+                       return;
 
-               discs.foreach((disc_id, uri) => {
-                       var disc_set_id = disc_id;
+               game_for_uri.add (uri);
 
-                       try {
-                               if (gameinfo != null)
-                                       disc_set_id = gameinfo.get_disc_set_id_for_disc_id (disc_id);
-                       }
-                       catch (Error e) {
-                               debug (_("Disc with disc_id %s is unknown"), disc_id);
-                       }
+               var gameinfo = get_gameinfo ();
+               var disc_id = get_disc_id (uri);
+               var disc_set_id = gameinfo.get_disc_set_id_for_disc_id (disc_id);
 
-                       if (!(disc_set_id in disc_sets))
-                               disc_sets[disc_set_id] = new GenericSet<string> (GLib.str_hash, 
GLib.str_equal);
+               return_if_fail (media_for_disc_id.contains (disc_id) == game_for_disc_set_id.contains 
(disc_set_id));
 
-                       disc_sets[disc_set_id].add (disc_id);
-               });
+               // Check whether we already have a media and by extension a media set
+               // and a game for this disc ID. If such a case, simply add the new URI.
+               if (media_for_disc_id.contains (disc_id)) {
+                       var media = media_for_disc_id.lookup (disc_id);
+                       media.add_uri (uri);
+                       game_for_uri[uri] = game_for_disc_set_id[disc_set_id];
 
-               disc_sets.foreach ((disc_set_id, disc_set) => {
-                       try {
-                               if (!(disc_set_id in games))
-                                       games[disc_set_id] = game_for_disc_set (disc_set);
-                       }
-                       catch (Error e) {
-                               warning (e.message);
-                       }
-               });
+                       return;
+               }
 
-               games.foreach ((disc_set_id, game) => {
-                       game_callback (game);
-               });
-       }
+               // A game correspond to this URI but we don't have it yet: create it.
 
-       private string get_disc_id (string uri) throws Error {
-               var cue_file = File.new_for_uri (uri);
-               var cue_sheet = new CueSheet (cue_file);
-               var cue_track_node = cue_sheet.get_track (0);
-               var bin_file = cue_track_node.file.file;
-               var header = new PlayStationHeader (bin_file);
+               var new_medias = new HashTable<string, Media> (str_hash, str_equal);
+               Media[] new_medias_array = {};
+               var new_disc_ids = gameinfo.get_disc_set_ids_for_disc_id (disc_id);
+               foreach (var new_disc_id in new_disc_ids) {
+                       assert (!media_for_disc_id.contains (new_disc_id));
 
-               header.check_validity ();
+                       var title = new GameinfoDiscIdDiscTitle (gameinfo, new_disc_id);
+                       var media = new Media (title);
+                       new_medias_array += media;
+                       new_medias[new_disc_id] = media;
+               }
 
-               return header.disc_id;
-       }
+               var media = new_medias.lookup (disc_id);
+               media.add_uri (uri);
 
-       private Game game_for_disc_set (GenericSet<string> disc_set) throws Error {
-               Media[] medias = {};
+               var icon = GLib.Icon.new_for_string (ICON_NAME);
+               var media_set = new MediaSet (new_medias_array, icon);
+               var game = create_game (media_set, disc_set_id, uri);
 
-               var gameinfo = get_gameinfo ();
-               var disc_list = disc_set.get_values ();
-               disc_list.sort_with_data ((disc_id_a, disc_id_b) => {
-                       int index_a;
-                       int index_b;
-                       try {
-                               index_a = gameinfo.get_disc_set_index_for_disc_id (disc_id_a);
-                               index_b = gameinfo.get_disc_set_index_for_disc_id (disc_id_b);
-                       }
-                       catch (Error e) {
-                               debug (e.message);
-
-                               return 0;
-                       }
-
-                       return (int) (index_a > index_b) - (int) (index_a < index_b);
-               });
+               // Creating the Medias, MediaSet and Game worked, we can save them.
 
-               disc_list.foreach ((disc_id) => {
-                       var uri = discs[disc_id];
-                       var title = new GameinfoDiscIdDiscTitle (gameinfo, disc_id);
-                       var media = new Media (title);
-                       media.add_uri (uri);
-                       medias += media;
-               });
-
-               var icon = GLib.Icon.new_for_string (ICON_NAME);
-               var media_set = new MediaSet (medias, icon);
+               foreach (var new_disc_id in new_medias.get_keys ())
+                       media_for_disc_id[new_disc_id] = new_medias[new_disc_id];
 
-               var game = game_for_uris (media_set);
+               game_for_uri[uri] = game;
+               game_for_disc_set_id[disc_set_id] = game;
+               game_added (game);
+       }
 
-               return game;
+       public async void foreach_game (GameCallback game_callback) {
+               game_for_uri.foreach ((uri, game) => game_callback (game));
        }
 
-       private Game game_for_uris (MediaSet media_set) throws Error {
-               var selected_media = media_set.get_selected_media (0);
-               var uris = selected_media.get_uris ();
-               // FIXME Check that there is at least one URI.
-               var uri = uris[0];
+       private string get_disc_id (string uri) throws Error {
                var cue_file = File.new_for_uri (uri);
                var cue_sheet = new CueSheet (cue_file);
                var cue_track_node = cue_sheet.get_track (0);
                var bin_file = cue_track_node.file.file;
                var header = new PlayStationHeader (bin_file);
+
                header.check_validity ();
 
+               return header.disc_id;
+       }
+
+       private Game create_game (MediaSet media_set, string disc_set_id, string uri) throws Error {
                var gameinfo = get_gameinfo ();
-               var uid = new PlayStationUid (header.disc_id);
+               var uid = new PlayStationUid (disc_set_id);
                var title = new CompositeTitle ({
-                       new GameinfoDiscIdGameTitle (gameinfo, header.disc_id),
+                       new GameinfoDiscIdGameTitle (gameinfo, disc_set_id),
                        new FilenameTitle (uri)
                });
                var icon = new DummyIcon ();
@@ -159,7 +125,7 @@ public class Games.PlayStationGameFactory : Object, UriGameFactory {
                var cover = new CompositeCover ({
                        new LocalCover (uri),
                        new GriloCover (media, uid)});
-               var input_capabilities = new GameinfoDiscIdInputCapabilities (gameinfo, header.disc_id);
+               var input_capabilities = new GameinfoDiscIdInputCapabilities (gameinfo, disc_set_id);
                var core_source = new RetroCoreSource (PLATFORM, { SEARCHED_MIME_TYPE, SPECIFIC_MIME_TYPE });
                var runner = new RetroRunner.for_media_set_and_input_capabilities (core_source, media_set, 
uid, input_capabilities, title);