Imported Upstream version 0.18.1upstream/0.18.1

1 files changed, 675 insertions, 0 deletions

diff --git a/src/MetadataWriter.vala b/src/MetadataWriter.vala
new file mode 100644
index 0000000..aee5855
--- /dev/null
+++ b/src/MetadataWriter.vala
@@ -0,0 +1,675 @@
+/* Copyright 2010-2014 Yorba Foundation
+ *
+ * This software is licensed under the GNU Lesser General Public License
+ * (version 2.1 or later).  See the COPYING file in this distribution.
+ */
+
+// MetadataWriter tracks LibraryPhotos for alterations to their metadata and commits those changes
+// in a timely manner to their backing files.  Because only the MetadataWriter knows when the
+// metadata has been properly committed, it is also responsible for updating the metadata-dirty
+// flag in Photo.  Thus, MetadataWriter should *always* be running, even if the user has turned off
+// the feature, so if they turn it on MetadataWriter can properly go out and update the backing
+// files.
+
+public class MetadataWriter : Object {
+    public const uint COMMIT_DELAY_MSEC = 3000;
+    public const uint COMMIT_SPACING_MSEC = 50;
+    
+    private const string[] INTERESTED_PHOTO_METADATA_DETAILS = { "name", "comment", "rating", "exposure-time" };
+    
+    private class CommitJob : BackgroundJob {
+        public LibraryPhoto photo;
+        public Gee.Set<string>? current_keywords;
+        public Photo.ReimportMasterState reimport_master_state = null;
+        public Photo.ReimportEditableState reimport_editable_state = null;
+        public Error? err = null;
+        
+        public CommitJob(MetadataWriter owner, LibraryPhoto photo, Gee.Set<string>? keywords) {
+            base (owner, owner.on_update_completed, new Cancellable(), owner.on_update_cancelled);
+
+            this.photo = photo;
+            current_keywords = keywords;
+        }
+
+        public override void execute() {
+            try {
+                commit_master();
+                commit_editable();
+            } catch (Error err) {
+                this.err = err;
+            }
+        }
+        
+        private void commit_master() throws Error {
+            // If we have an editable, any orientation changes should be written only to it;
+            // otherwise, we'll end up ruining the original, and as such, breaking the
+            // ability to revert to it.
+            bool skip_orientation = photo.has_editable();
+            
+            if (!photo.get_master_file_format().can_write_metadata())
+                return;
+            
+            PhotoMetadata metadata = photo.get_master_metadata();
+            if (update_metadata(metadata, skip_orientation)) {
+                LibraryMonitor.blacklist_file(photo.get_master_file(), "MetadataWriter.commit_master");
+                try {
+                    photo.persist_master_metadata(metadata, out reimport_master_state);
+                } finally {
+                    LibraryMonitor.unblacklist_file(photo.get_master_file());
+                }
+            }
+        }
+        
+        private void commit_editable() throws Error {
+            if (!photo.has_editable() || !photo.get_editable_file_format().can_write_metadata())
+                return;
+            
+            PhotoMetadata? metadata = photo.get_editable_metadata();
+            assert(metadata != null);
+            
+            if (update_metadata(metadata)) {
+                LibraryMonitor.blacklist_file(photo.get_editable_file(), "MetadataWriter.commit_editable");
+                try {
+                    photo.persist_editable_metadata(metadata, out reimport_editable_state);
+                } finally {
+                    LibraryMonitor.unblacklist_file(photo.get_editable_file());
+                }
+            }
+        }
+        
+        private bool update_metadata(PhotoMetadata metadata, bool skip_orientation = false) {
+            bool changed = false;
+            
+            // title (caption)
+            string? current_title = photo.get_title();
+            if (current_title != metadata.get_title()) {
+                metadata.set_title(current_title);
+                changed = true;
+            }
+            
+            // comment
+            string? current_comment = photo.get_comment();
+            if (current_comment != metadata.get_comment()) {
+                metadata.set_comment(current_comment);
+                changed = true;
+            }
+            
+            // rating
+            Rating current_rating = photo.get_rating();
+            if (current_rating != metadata.get_rating()) {
+                metadata.set_rating(current_rating);
+                changed = true;
+            }
+            
+            // exposure date/time
+            time_t current_exposure_time = photo.get_exposure_time();
+            time_t metadata_exposure_time = 0;
+            MetadataDateTime? metadata_exposure_date_time = metadata.get_exposure_date_time();
+            if (metadata_exposure_date_time != null)
+                metadata_exposure_time = metadata_exposure_date_time.get_timestamp();
+            if (current_exposure_time != metadata_exposure_time) {
+                metadata.set_exposure_date_time(current_exposure_time != 0
+                    ? new MetadataDateTime(current_exposure_time)
+                    : null);
+                changed = true;
+            }
+
+            // tags (keywords) ... replace (or clear) entirely rather than union or intersection
+            Gee.Set<string> safe_keywords = new Gee.HashSet<string>();
+
+            // Since the tags are stored in an image file's `keywords' field in
+            // non-hierarchical format, before checking whether the tags that
+            // should be associated with this image have been written, we'll need
+            // to produce non-hierarchical versions of the tags to be tested.
+            // get_user_visible_name() does this by returning the most deeply-nested
+            // portion of a given hierarchical tag; that is, for a tag "/a/b/c",
+            // it'll return "c", which is exactly the form we want here.
+            if (current_keywords != null) {
+                foreach(string tmp in current_keywords) {
+                    Tag tag = Tag.for_path(tmp);
+                    safe_keywords.add(tag.get_user_visible_name());
+                }
+            }
+
+            if (!equal_sets(safe_keywords, metadata.get_keywords())) {
+                metadata.set_keywords(current_keywords);
+                changed = true;
+            }
+
+            // orientation
+            if (!skip_orientation) {
+                Orientation current_orientation = photo.get_orientation();
+                if (current_orientation != metadata.get_orientation()) {
+                    metadata.set_orientation(current_orientation);
+                    changed = true;
+                }
+            }
+
+            // add the software name/version only if updating the metadata in the file
+            if (changed)
+                metadata.set_software(Resources.APP_TITLE, Resources.APP_VERSION);
+            
+            return changed;
+        }
+    }
+    
+    private static MetadataWriter instance = null;
+    
+    private Workers workers = new Workers(1, false);
+    private bool enabled = false;
+    private HashTimedQueue<LibraryPhoto> dirty;
+    private Gee.HashMap<LibraryPhoto, CommitJob> pending = new Gee.HashMap<LibraryPhoto, CommitJob>();
+    private Gee.HashSet<string> interested_photo_details = new Gee.HashSet<string>();
+    private LibraryPhoto? ignore_photo_alteration = null;
+    private uint outstanding_total = 0;
+    private uint outstanding_completed = 0;
+    private bool closed = false;
+    private int pause_count = 0;
+    private Gee.HashSet<LibraryPhoto> importing_photos = new Gee.HashSet<LibraryPhoto>();
+    
+    public signal void progress(uint completed, uint total);
+    
+    private MetadataWriter() {
+        dirty = new HashTimedQueue<LibraryPhoto>(COMMIT_DELAY_MSEC, on_photo_dequeued);
+        dirty.set_dequeue_spacing_msec(COMMIT_SPACING_MSEC);
+        
+        // start with the writer paused, waiting for the LibraryMonitor initial discovery to
+        // complete (note that if the LibraryMonitor is ever disabled, the MetadataWriter will not
+        // start on its own)
+        pause();
+        
+        // convert all interested metadata Alteration details into lookup hash
+        foreach (string detail in INTERESTED_PHOTO_METADATA_DETAILS)
+            interested_photo_details.add(detail);
+
+        // sync up with the configuration system
+        enabled = Config.Facade.get_instance().get_commit_metadata_to_masters();
+        Config.Facade.get_instance().commit_metadata_to_masters_changed.connect(on_config_changed);
+        
+        // add all current photos to look for ones that are dirty and need updating
+        force_rescan();
+        
+        LibraryPhoto.global.media_import_starting.connect(on_importing_photos);
+        LibraryPhoto.global.media_import_completed.connect(on_photos_imported);
+        LibraryPhoto.global.contents_altered.connect(on_photos_added_removed);
+        LibraryPhoto.global.items_altered.connect(on_photos_altered);
+        LibraryPhoto.global.frozen.connect(on_collection_frozen);
+        LibraryPhoto.global.thawed.connect(on_collection_thawed);
+        LibraryPhoto.global.items_destroyed.connect(on_photos_destroyed);
+        
+        Tag.global.items_altered.connect(on_tags_altered);
+        Tag.global.container_contents_altered.connect(on_tag_contents_altered);
+        Tag.global.backlink_to_container_removed.connect(on_tag_backlink_removed);
+        Tag.global.frozen.connect(on_collection_frozen);
+        Tag.global.thawed.connect(on_collection_thawed);
+        
+        Application.get_instance().exiting.connect(on_application_exiting);
+        
+        LibraryMonitorPool.get_instance().monitor_installed.connect(on_monitor_installed);
+        LibraryMonitorPool.get_instance().monitor_destroyed.connect(on_monitor_destroyed);
+    }
+    
+    ~MetadataWriter() {
+        Config.Facade.get_instance().commit_metadata_to_masters_changed.disconnect(on_config_changed);
+        
+        LibraryPhoto.global.media_import_starting.disconnect(on_importing_photos);
+        LibraryPhoto.global.media_import_completed.disconnect(on_photos_imported);
+        LibraryPhoto.global.contents_altered.disconnect(on_photos_added_removed);
+        LibraryPhoto.global.items_altered.disconnect(on_photos_altered);
+        LibraryPhoto.global.frozen.disconnect(on_collection_frozen);
+        LibraryPhoto.global.thawed.disconnect(on_collection_thawed);
+        LibraryPhoto.global.items_destroyed.disconnect(on_photos_destroyed);
+        
+        Tag.global.items_altered.disconnect(on_tags_altered);
+        Tag.global.container_contents_altered.disconnect(on_tag_contents_altered);
+        Tag.global.backlink_to_container_removed.disconnect(on_tag_backlink_removed);
+        Tag.global.frozen.disconnect(on_collection_frozen);
+        Tag.global.thawed.disconnect(on_collection_thawed);
+        
+        Application.get_instance().exiting.disconnect(on_application_exiting);
+        
+        LibraryMonitorPool.get_instance().monitor_installed.disconnect(on_monitor_installed);
+        LibraryMonitorPool.get_instance().monitor_destroyed.disconnect(on_monitor_destroyed);
+    }
+    
+    public static void init() {
+        instance = new MetadataWriter();
+    }
+    
+    public static void terminate() {
+        if (instance != null)
+            instance.close();
+        
+        instance = null;
+    }
+    
+    public static MetadataWriter get_instance() {
+        return instance;
+    }
+    
+    // This will examine all photos for dirty metadata and schedule commits if enabled.
+    public void force_rescan() {
+        schedule_if_dirty((Gee.Collection<LibraryPhoto>) LibraryPhoto.global.get_all(), "force rescan");
+    }
+    
+    public void pause() {
+        if (pause_count++ != 0)
+            return;
+        
+        dirty.pause();
+        
+        progress(0, 0);
+    }
+    
+    public void unpause() {
+        if (pause_count == 0 || --pause_count != 0)
+            return;
+        
+        dirty.unpause();
+    }
+    
+    public void close() {
+        if (closed)
+            return;
+        
+        cancel_all(true);
+        
+        closed = true;
+    }
+    
+    private void on_config_changed() {
+        bool value = Config.Facade.get_instance().get_commit_metadata_to_masters();
+        
+        if (enabled == value)
+            return;
+        
+        enabled = value;
+        if (enabled)
+            force_rescan();
+        else
+            cancel_all(false);
+    }
+    
+    private void on_application_exiting() {
+        close();
+    }
+    
+    private void on_monitor_installed(LibraryMonitor monitor) {
+        monitor.discovery_completed.connect(on_discovery_completed);
+    }
+
+    private void on_monitor_destroyed(LibraryMonitor monitor) {
+        monitor.discovery_completed.disconnect(on_discovery_completed);
+    }
+    
+    private void on_discovery_completed() {
+        unpause();
+    }
+    
+    private void on_collection_frozen() {
+        pause();
+    }
+    
+    private void on_collection_thawed() {
+        unpause();
+    }
+    
+    private void on_importing_photos(Gee.Collection<MediaSource> media_sources) {
+        importing_photos.add_all((Gee.Collection<LibraryPhoto>) media_sources);
+    }
+    
+    private void on_photos_imported(Gee.Collection<MediaSource> media_sources) {
+        importing_photos.remove_all((Gee.Collection<LibraryPhoto>) media_sources);
+    }
+    
+    private void on_photos_added_removed(Gee.Iterable<DataObject>? added,
+        Gee.Iterable<DataObject>? removed) {
+        // no reason to go through this exercise if auto-commit is disabled
+        if (added != null && enabled)
+            schedule_if_dirty((Gee.Iterable<LibraryPhoto>) added, "added to LibraryPhoto.global");
+        
+        // want to cancel jobs no matter what, however
+        if (removed != null) {
+            bool cancelled = false;
+            foreach (DataObject object in removed)
+                cancelled = cancel_job((LibraryPhoto) object) || cancelled;
+            
+            if (cancelled)
+                progress(outstanding_completed, outstanding_total);
+        }
+    }
+    
+    private void on_photos_altered(Gee.Map<DataObject, Alteration> items) {
+        Gee.HashSet<LibraryPhoto> photos = null;
+        foreach (DataObject object in items.keys) {
+            LibraryPhoto photo = (LibraryPhoto) object;
+            
+            // ignore this signal on this photo (means it's coming up from completing the metadata
+            // update)
+            if (photo == ignore_photo_alteration)
+                continue;
+            
+            Alteration alteration = items.get(object);
+            
+            // if an image:orientation detail, write that out
+            if (alteration.has_detail("image", "orientation")) {
+                if (photos == null)
+                    photos = new Gee.HashSet<LibraryPhoto>();
+                
+                photos.add(photo);
+                
+                continue;
+            }
+            
+            // get all "metadata" details for this alteration
+            Gee.Collection<string>? details = alteration.get_details("metadata");
+            if (details == null)
+                continue;
+            
+            // only enqueue an update if an alteration of metadata actually written out occurs
+            foreach (string detail in details) {
+                if (interested_photo_details.contains(detail)) {
+                    if (photos == null)
+                        photos = new Gee.HashSet<LibraryPhoto>();
+                    
+                    photos.add(photo);
+                    
+                    break;
+                }
+            }
+        }
+        
+        if (photos != null)
+            photos_are_dirty(photos, "alteration", false);
+    }
+    
+    private void on_photos_destroyed(Gee.Collection<DataSource> destroyed) {
+        foreach (DataSource source in destroyed) {
+            LibraryPhoto photo = (LibraryPhoto) source;
+            cancel_job(photo);
+            importing_photos.remove(photo);
+        }
+    }
+    
+    private void on_tags_altered(Gee.Map<DataObject, Alteration> map) {
+        Gee.HashSet<LibraryPhoto>? photos = null;
+        foreach (DataObject object in map.keys) {
+            if (!map.get(object).has_detail("metadata", "name"))
+                continue;
+            
+            if (photos == null)
+                photos = new Gee.HashSet<LibraryPhoto>();
+            
+            foreach (MediaSource media in ((Tag) object).get_sources()) {
+                LibraryPhoto? photo = media as LibraryPhoto;
+                if (photo != null)
+                    photos.add(photo);
+            }
+        }
+        
+        if (photos != null)
+            photos_are_dirty(photos, "tag renamed", false);
+    }
+    
+    private void on_tag_contents_altered(ContainerSource container, Gee.Collection<DataSource>? added,
+        bool relinking, Gee.Collection<DataSource>? removed, bool unlinking) {
+        Tag tag = (Tag) container;
+        
+        if (added != null && !relinking) {
+            Gee.ArrayList<LibraryPhoto> added_photos = new Gee.ArrayList<LibraryPhoto>();
+            foreach (DataSource source in added) {
+                LibraryPhoto? photo =  source as LibraryPhoto;
+                if (photo != null && !importing_photos.contains(photo))
+                    added_photos.add(photo);
+            }
+            
+            photos_are_dirty(added_photos, "added to %s".printf(tag.to_string()), false);
+        }
+        
+        if (removed != null && !unlinking) {
+            Gee.ArrayList<LibraryPhoto> removed_photos = new Gee.ArrayList<LibraryPhoto>();
+            foreach (DataSource source in removed) {
+                LibraryPhoto? photo = source as LibraryPhoto;
+                if (photo != null)
+                    removed_photos.add(photo);
+            }
+            
+            photos_are_dirty(removed_photos, "removed from %s".printf(tag.to_string()), false);
+        }
+    }
+    
+    private void on_tag_backlink_removed(ContainerSource container, Gee.Collection<DataSource> sources) {
+        Gee.ArrayList<LibraryPhoto> photos = new Gee.ArrayList<LibraryPhoto>();
+        foreach (DataSource source in sources) {
+            LibraryPhoto? photo = source as LibraryPhoto;
+            if (photo != null)
+                photos.add(photo);
+        }
+        
+        photos_are_dirty(photos, "backlink removed from %s".printf(container.to_string()), false);
+    }
+    
+    private void count_enqueued_work(int count, bool report) {
+        outstanding_total += count;
+        
+#if TRACE_METADATA_WRITER
+        debug("[%u/%u] %d metadata jobs enqueued", outstanding_completed, outstanding_total, count);
+#endif
+        
+        if (report)
+            progress(outstanding_completed, outstanding_total);
+    }
+    
+    private void count_cancelled_work(int count, bool report) {
+        outstanding_total = (outstanding_total >= count) ? outstanding_total - count : 0;
+        if (outstanding_completed >= outstanding_total) {
+            outstanding_completed = 0;
+            outstanding_total = 0;
+        }
+        
+#if TRACE_METADATA_WRITER
+        debug("[%u/%u] %d metadata jobs cancelled", outstanding_completed, outstanding_total, count);
+#endif
+        
+        if (report)
+            progress(outstanding_completed, outstanding_total);
+    }
+    
+    private void count_completed_work(int count, bool report) {
+        outstanding_completed += count;
+        if (outstanding_completed >= outstanding_total) {
+            outstanding_completed = 0;
+            outstanding_total = 0;
+        }
+        
+#if TRACE_METADATA_WRITER
+        debug("[%u/%u] %d metadata jobs completed", outstanding_completed, outstanding_total, count);
+#endif
+        
+        if (report)
+            progress(outstanding_completed, outstanding_total);
+    }
+    
+    private void schedule_if_dirty(Gee.Iterable<MediaSource> media_sources, string reason) {
+        Gee.ArrayList<LibraryPhoto> photos = null;
+        foreach (MediaSource media in media_sources) {
+            LibraryPhoto? photo = media as LibraryPhoto;
+            if (photo == null)
+                continue;
+            
+            // if in the importing stage, do not schedule for commit
+            if (importing_photos.contains(photo))
+                continue;
+            
+            if (photo.is_master_metadata_dirty()) {
+                if (photos == null)
+                    photos = new Gee.ArrayList<LibraryPhoto>();
+                
+                photos.add(photo);
+            }
+        }
+        
+        if (photos != null)
+            photos_are_dirty(photos, reason, true);
+    }
+    
+    // No photos are dirty.  The human body is a thing of beauty and grace.
+    private void photos_are_dirty(Gee.Collection<LibraryPhoto> photos, string reason, bool already_marked) {
+        if (photos.size == 0)
+            return;
+        
+        // cancel all outstanding and pending jobs
+        foreach (LibraryPhoto photo in photos)
+            cancel_job(photo);
+        
+        // mark all the photos as dirty
+        if (!already_marked) {
+            try {
+                LibraryPhoto.global.transaction_controller.begin();
+                
+                foreach (LibraryPhoto photo in photos)
+                    photo.set_master_metadata_dirty(true);
+                
+                LibraryPhoto.global.transaction_controller.commit();
+            } catch (Error err) {
+                if (err is DatabaseError)
+                    AppWindow.database_error((DatabaseError) err);
+                else
+                    error("Unable to mark metadata as dirty: %s", err.message);
+            }
+        }
+        
+        // ok to drop this on the floor, now that they're marked dirty (will attempt to write them
+        // out the next time MetadataWriter runs)
+        if (closed || !enabled)
+            return;
+        
+#if TRACE_METADATA_WRITER
+        debug("[%s] adding %d photos to dirty list", reason, photos.size);
+#endif
+        
+        foreach (LibraryPhoto photo in photos) {
+            bool enqueued = dirty.enqueue(photo);
+            assert(enqueued);
+        }
+        
+        count_enqueued_work(photos.size, true);
+    }
+    
+    private void cancel_all(bool wait) {
+        dirty.clear();
+        
+        foreach (CommitJob job in pending.values)
+            job.cancel();
+        
+        if (wait)
+            workers.wait_for_empty_queue();
+        
+        count_cancelled_work(int.MAX, true);
+    }
+    
+    private bool cancel_job(LibraryPhoto photo) {
+        bool cancelled = false;
+        
+        if (pending.has_key(photo)) {
+            pending.get(photo).cancel();
+            cancelled = true;
+        }
+        
+        if (dirty.contains(photo)) {
+            bool removed = dirty.remove_first(photo);
+            assert(removed);
+            
+            assert(!dirty.contains(photo));
+            
+            count_cancelled_work(1, false);
+            cancelled = true;
+        }
+        
+        return cancelled;
+    }
+    
+    private void on_photo_dequeued(LibraryPhoto photo) {
+        if (!enabled) {
+            count_cancelled_work(1, true);
+            
+            return;
+        }
+        
+        Gee.Set<string>? keywords = null;
+        Gee.Collection<Tag>? tags = Tag.global.fetch_for_source(photo);
+        if (tags != null) {
+            keywords = new Gee.HashSet<string>();
+            foreach (Tag tag in tags)
+                keywords.add(tag.get_name());
+        }
+        
+        CommitJob job = new CommitJob(this, photo, keywords);
+        pending.set(photo, job);
+        
+#if TRACE_METADATA_WRITER
+        debug("%s dequeued for metadata commit, %d pending", photo.to_string(), pending.size);
+#endif
+        
+        workers.enqueue(job);
+    }
+    
+    private void on_update_completed(BackgroundJob j) {
+        CommitJob job = (CommitJob) j;
+        
+        if (job.err != null)
+            warning("Unable to update metadata for %s: %s", job.photo.to_string(), job.err.message);
+        else
+            message("Completed writing metadata for %s", job.photo.to_string());
+        
+        bool removed = pending.unset(job.photo);
+        assert(removed);
+        
+        // since there's potentially multiple state-change operations here, use the transaction
+        // controller
+        LibraryPhoto.global.transaction_controller.begin();
+        
+        if (job.reimport_master_state != null || job.reimport_editable_state != null) {
+            // finish_update_*_metadata are going to issue an "altered" signal, and we want to 
+            // ignore it
+            assert(ignore_photo_alteration == null);
+            ignore_photo_alteration = job.photo;
+            try {
+                if (job.reimport_master_state != null)
+                    job.photo.finish_update_master_metadata(job.reimport_master_state);
+                
+                if (job.reimport_editable_state != null)
+                    job.photo.finish_update_editable_metadata(job.reimport_editable_state);
+            } catch (DatabaseError err) {
+                AppWindow.database_error(err);
+            } finally {
+                // this assertion guards against reentrancy
+                assert(ignore_photo_alteration == job.photo);
+                ignore_photo_alteration = null;
+            }
+        } else {
+#if TRACE_METADATA_WRITER
+            debug("[%u/%u] No metadata changes for %s", outstanding_completed, outstanding_total,
+                job.photo.to_string());
+#endif
+        }
+        
+        try {
+            job.photo.set_master_metadata_dirty(false);
+        } catch (DatabaseError err) {
+            AppWindow.database_error(err);
+        }
+        
+        LibraryPhoto.global.transaction_controller.commit();
+        
+        count_completed_work(1, true);
+    }
+    
+    private void on_update_cancelled(BackgroundJob j) {
+        bool removed = pending.unset(((CommitJob) j).photo);
+        assert(removed);
+        
+        count_cancelled_work(1, true);
+    }
+}
+