diff options
Diffstat (limited to 'src/faces/Face.vala')
| -rw-r--r-- | src/faces/Face.vala | 681 |
1 files changed, 681 insertions, 0 deletions
diff --git a/src/faces/Face.vala b/src/faces/Face.vala new file mode 100644 index 0000000..9be33c9 --- /dev/null +++ b/src/faces/Face.vala @@ -0,0 +1,681 @@ +/* Copyright 2016 Software Freedom Conservancy Inc. + * + * This software is licensed under the GNU Lesser General Public License + * (version 2.1 or later). See the COPYING file in this distribution. + */ + +#if ENABLE_FACES +public class FaceSourceCollection : ContainerSourceCollection { + private Gee.HashMap<string, Face> name_map = new Gee.HashMap<string, Face> + ((Gee.HashDataFunc)Face.hash_name_string, (Gee.EqualDataFunc)Face.equal_name_strings); + private Gee.HashMap<MediaSource, Gee.List<Face>> source_map = + new Gee.HashMap<MediaSource, Gee.List<Face>>(); + + public FaceSourceCollection() { + base (Face.TYPENAME, "FaceSourceCollection", get_face_key); + + attach_collection(LibraryPhoto.global); + } + + public override bool holds_type_of_source(DataSource source) { + return source is Face; + } + + private static int64 get_face_key(DataSource source) { + return ((Face) source).get_instance_id(); + } + + protected override Gee.Collection<ContainerSource>? get_containers_holding_source(DataSource source) { + return fetch_for_source((MediaSource) source); + } + + public override ContainerSource? convert_backlink_to_container(SourceBacklink backlink) { + FaceID face_id = FaceID(backlink.instance_id); + + Face? face = fetch(face_id); + if (face != null) + return face; + + foreach (ContainerSource container in get_holding_tank()) { + face = (Face) container; + if (face.get_face_id().id == face_id.id) + return face; + } + + return null; + } + + public Face? fetch(FaceID face_id) { + return (Face) fetch_by_key(face_id.id); + } + + public bool exists(string name) { + return name_map.has_key(name); + } + + public Gee.Collection<string> get_all_names() { + return name_map.keys; + } + + // Returns a list of all Faces associated with the media source in no particular order. + // + // NOTE: As a search optimization, this returns the list that is maintained by Faces.global. + // Do NOT modify this list. + public Gee.List<Face>? fetch_for_source(MediaSource source) { + return source_map.get(source); + } + + // Returns null if not Face with name exists. + public Face? fetch_by_name(string name) { + return name_map.get(name); + } + + public Face? restore_face_from_holding_tank(string name) { + Face? found = null; + foreach (ContainerSource container in get_holding_tank()) { + Face face = (Face) container; + if (face.get_name() == name) { + found = face; + + break; + } + } + + if (found != null) { + bool relinked = relink_from_holding_tank(found); + assert(relinked); + } + + return found; + } + + protected override void notify_items_added(Gee.Iterable<DataObject> added) { + foreach (DataObject object in added) { + Face face = (Face) object; + + assert(!name_map.has_key(face.get_name())); + name_map.set(face.get_name(), face); + } + + base.notify_items_added(added); + } + + protected override void notify_items_removed(Gee.Iterable<DataObject> removed) { + foreach (DataObject object in removed) { + Face face = (Face) object; + + bool unset = name_map.unset(face.get_name()); + assert(unset); + } + + base.notify_items_removed(removed); + } + + protected override void notify_items_altered(Gee.Map<DataObject, Alteration> map) { + foreach (DataObject object in map.keys) { + Face face = (Face) object; + + string? old_name = null; + + // look for this face being renamed + Gee.MapIterator<string, Face> iter = name_map.map_iterator(); + while (iter.next()) { + if (!iter.get_value().equals(face)) + continue; + + old_name = iter.get_key(); + + break; + } + + assert(old_name != null); + + if (face.get_name() != old_name) { + name_map.unset(old_name); + name_map.set(face.get_name(), face); + } + } + + base.notify_items_altered(map); + } + + protected override void notify_container_contents_added(ContainerSource container, + Gee.Collection<DataObject> added, bool relinking) { + Face face = (Face) container; + Gee.Collection<MediaSource> sources = (Gee.Collection<MediaSource>) added; + + foreach (MediaSource source in sources) { + Gee.List<Face>? faces = source_map.get(source); + if (faces == null) { + faces = new Gee.ArrayList<Face>(); + source_map.set(source, faces); + } + + bool is_added = faces.add(face); + assert(is_added); + } + + base.notify_container_contents_added(container, added, relinking); + } + + protected override void notify_container_contents_removed(ContainerSource container, + Gee.Collection<DataObject> removed, bool unlinking) { + Face face = (Face) container; + Gee.Collection<MediaSource> sources = (Gee.Collection<MediaSource>) removed; + + foreach (MediaSource source in sources) { + Gee.List<Face>? faces = source_map.get(source); + assert(faces != null); + + bool is_removed = faces.remove(face); + assert(is_removed); + + if (faces.size == 0) + source_map.unset(source); + } + + base.notify_container_contents_removed(container, removed, unlinking); + } +} + +public class Face : DataSource, ContainerSource, Proxyable, Indexable { + public const string TYPENAME = "face"; + + private class FaceSnapshot : SourceSnapshot { + private FaceRow row; + private Gee.HashSet<MediaSource> sources = new Gee.HashSet<MediaSource>(); + + public FaceSnapshot(Face face) { + // stash current state of Face + row = face.row; + + // stash photos attached to this face ... if any are destroyed, the face + // cannot be reconstituted + foreach (MediaSource source in face.get_sources()) + sources.add(source); + + LibraryPhoto.global.item_destroyed.connect(on_source_destroyed); + } + + ~FaceSnapshot() { + LibraryPhoto.global.item_destroyed.disconnect(on_source_destroyed); + } + + public FaceRow get_row() { + return row; + } + + public override void notify_broken() { + row = new FaceRow(); + sources.clear(); + + base.notify_broken(); + } + + private void on_source_destroyed(DataSource source) { + if (sources.contains((MediaSource) source)) + notify_broken(); + } + } + + private class FaceProxy : SourceProxy { + public FaceProxy(Face face) { + base (face); + } + + public override DataSource reconstitute(int64 object_id, SourceSnapshot snapshot) { + return Face.reconstitute(object_id, ((FaceSnapshot) snapshot).get_row()); + } + } + + public static FaceSourceCollection global = null; + + private FaceRow row; + private ViewCollection media_views; + private string? name_collation_key = null; + private bool unlinking = false; + private bool relinking = false; + private string? indexable_keywords = null; + + private Face(FaceRow row, int64 object_id = INVALID_OBJECT_ID) { + base (object_id); + + this.row = row; + + // normalize user text + this.row.name = prep_face_name(this.row.name); + + Gee.Set<PhotoID?> photo_id_list = FaceLocation.get_photo_ids_by_face(this); + Gee.ArrayList<Photo> photo_list = new Gee.ArrayList<Photo>(); + Gee.ArrayList<ThumbnailView> thumbnail_views = new Gee.ArrayList<ThumbnailView>(); + if (photo_id_list != null) { + foreach (PhotoID photo_id in photo_id_list) { + MediaSource? current_source = + LibraryPhoto.global.fetch_by_source_id(PhotoID.upgrade_photo_id_to_source_id(photo_id)); + if (current_source == null) + continue; + + photo_list.add((Photo) current_source); + thumbnail_views.add(new ThumbnailView(current_source)); + } + } + + // add to internal ViewCollection, which maintains media sources associated with this face + media_views = new ViewCollection("ViewCollection for face %s".printf(row.face_id.id.to_string())); + media_views.add_many(thumbnail_views); + + // need to do this manually here because only want to monitor photo_contents_altered + // after add_many() here; but need to keep the FaceSourceCollection apprised + if (photo_list.size > 0) { + global.notify_container_contents_added(this, photo_list, false); + global.notify_container_contents_altered(this, photo_list, false, null, false); + } + + // monitor ViewCollection to (a) keep the in-memory list of source ids up-to-date, and + // (b) update the database whenever there's a change; + media_views.contents_altered.connect(on_media_views_contents_altered); + + // monitor the global collections to trap when photos are destroyed, then + // automatically remove from the face + LibraryPhoto.global.items_destroyed.connect(on_sources_destroyed); + + update_indexable_keywords(); + } + + ~Face() { + media_views.contents_altered.disconnect(on_media_views_contents_altered); + LibraryPhoto.global.items_destroyed.disconnect(on_sources_destroyed); + } + + public static void init(ProgressMonitor? monitor) { + global = new FaceSourceCollection(); + + // scoop up all the rows at once + Gee.List<FaceRow?> rows = null; + try { + rows = FaceTable.get_instance().get_all_rows(); + } catch (DatabaseError err) { + AppWindow.database_error(err); + } + + // turn them into Face objects + Gee.ArrayList<Face> faces = new Gee.ArrayList<Face>(); + Gee.ArrayList<Face> unlinked = new Gee.ArrayList<Face>(); + int count = rows.size; + for (int ctr = 0; ctr < count; ctr++) { + FaceRow row = rows.get(ctr); + + // make sure the face name is valid + string? name = prep_face_name(row.name); + if (name == null) { + // TODO: More graceful handling of this situation would be to rename the face or + // alert the user. + warning("Invalid face name \"%s\": removing from database", row.name); + try { + FaceTable.get_instance().remove(row.face_id); + } catch (DatabaseError err) { + warning("Unable to delete face \"%s\": %s", row.name, err.message); + } + + continue; + } + + row.name = name; + + Face face = new Face(row); + if (monitor != null) + monitor(ctr, count); + + if (face.get_sources_count() != 0) { + faces.add(face); + + continue; + } + + if (face.has_links()) { + face.rehydrate_backlinks(global, null); + unlinked.add(face); + + continue; + } + + warning("Empty face %s found with no backlinks, destroying", face.to_string()); + face.destroy_orphan(true); + } + + // add them all at once to the SourceCollection + global.add_many(faces); + global.init_add_many_unlinked(unlinked); + } + + public static void terminate() { + } + + public static int compare_names(void *a, void *b) { + Face *aface = (Face *) a; + Face *bface = (Face *) b; + + return String.precollated_compare(aface->get_name(), aface->get_name_collation_key(), + bface->get_name(), bface->get_name_collation_key()); + } + + public static uint hash_name_string(void *a) { + return String.collated_hash(a); + } + + public static bool equal_name_strings(void *a, void *b) { + return String.collated_equals(a, b); + } + + // Returns a Face for the name, creating a new empty one if it does not already exist. + // name should have already been prepared by prep_face_name. + public static Face for_name(string name) { + Face? face = global.fetch_by_name(name); + if (face == null) + face = global.restore_face_from_holding_tank(name); + + if (face != null) + return face; + + // create a new Face for this name + try { + face = new Face(FaceTable.get_instance().add(name)); + } catch (DatabaseError err) { + AppWindow.database_error(err); + } + + global.add(face); + + return face; + } + + // Utility function to cleanup a face name that comes from user input and prepare it for use + // in the system and storage in the database. Returns null if the name is unacceptable. + public static string? prep_face_name(string name) { + return prepare_input_text(name, PrepareInputTextOptions.DEFAULT, DEFAULT_USER_TEXT_INPUT_LENGTH); + } + + public override string get_typename() { + return TYPENAME; + } + + public override int64 get_instance_id() { + return get_face_id().id; + } + + public override string get_name() { + return row.name; + } + + public string get_name_collation_key() { + if (name_collation_key == null) + name_collation_key = row.name.collate_key(); + + return name_collation_key; + } + + public override string to_string() { + return "Face %s (%d sources)".printf(row.name, media_views.get_count()); + } + + public override bool equals(DataSource? source) { + // Validate uniqueness of primary key + Face? face = source as Face; + if (face != null) { + if (face != this) { + assert(face.row.face_id.id != row.face_id.id); + } + } + + return base.equals(source); + } + + public FaceID get_face_id() { + return row.face_id; + } + + public override SourceSnapshot? save_snapshot() { + return new FaceSnapshot(this); + } + + public SourceProxy get_proxy() { + return new FaceProxy(this); + } + + private static Face reconstitute(int64 object_id, FaceRow row) { + // fill in the row with the new FaceID for this reconstituted face + try { + row.face_id = FaceTable.get_instance().create_from_row(row); + } catch (DatabaseError err) { + AppWindow.database_error(err); + } + + Face face = new Face(row, object_id); + global.add(face); + + debug("Reconstituted %s", face.to_string()); + + return face; + } + + public bool has_links() { + return LibraryPhoto.global.has_backlink(get_backlink()); + } + + public SourceBacklink get_backlink() { + return new SourceBacklink.from_source(this); + } + + public void break_link(DataSource source) { + unlinking = true; + + detach((LibraryPhoto) source); + + unlinking = false; + } + + public void break_link_many(Gee.Collection<DataSource> sources) { + unlinking = true; + + detach_many((Gee.Collection<LibraryPhoto>) sources); + + unlinking = false; + } + + public void establish_link(DataSource source) { + relinking = true; + + attach((LibraryPhoto) source); + + relinking = false; + } + + public void establish_link_many(Gee.Collection<DataSource> sources) { + relinking = true; + + attach_many((Gee.Collection<LibraryPhoto>) sources); + + relinking = false; + } + + private void update_indexable_keywords() { + indexable_keywords = prepare_indexable_string(get_name()); + } + + public unowned string? get_indexable_keywords() { + return indexable_keywords; + } + + public void attach(MediaSource source) { + if (!media_views.has_view_for_source(source)) + media_views.add(new ThumbnailView(source)); + } + + public void attach_many(Gee.Collection<MediaSource> sources) { + Gee.ArrayList<ThumbnailView> view_list = new Gee.ArrayList<ThumbnailView>(); + foreach (MediaSource source in sources) { + if (!media_views.has_view_for_source(source)) + view_list.add(new ThumbnailView(source)); + } + + if (view_list.size > 0) + media_views.add_many(view_list); + } + + public bool detach(MediaSource source) { + DataView? view = media_views.get_view_for_source(source); + if (view == null) + return false; + + media_views.remove_marked(media_views.mark(view)); + + return true; + } + + public int detach_many(Gee.Collection<MediaSource> sources) { + int count = 0; + + Marker marker = media_views.start_marking(); + foreach (MediaSource source in sources) { + DataView? view = media_views.get_view_for_source(source); + if (view == null) + continue; + + marker.mark(view); + count++; + } + + media_views.remove_marked(marker); + + return count; + } + + // Returns false if the name already exists or a bad name. + public bool rename(string name) { + string? new_name = prep_face_name(name); + if (new_name == null) + return false; + + if (Face.global.exists(new_name)) + return false; + + try { + FaceTable.get_instance().rename(row.face_id, new_name); + } catch (DatabaseError err) { + AppWindow.database_error(err); + return false; + } + + row.name = new_name; + name_collation_key = null; + + update_indexable_keywords(); + + notify_altered(new Alteration.from_list("metadata:name, indexable:keywords")); + + return true; + } + + public bool contains(MediaSource source) { + return media_views.has_view_for_source(source); + } + + public int get_sources_count() { + return media_views.get_count(); + } + + public Gee.Collection<MediaSource> get_sources() { + return (Gee.Collection<MediaSource>) media_views.get_sources(); + } + + public void mirror_sources(ViewCollection view, CreateView mirroring_ctor) { + view.mirror(media_views, mirroring_ctor, null); + } + + private void on_media_views_contents_altered(Gee.Iterable<DataView>? added, + Gee.Iterable<DataView>? removed) { + Gee.Set<PhotoID?>? photo_id_list = FaceLocation.get_photo_ids_by_face(this); + + Gee.Collection<Photo> added_photos = null; + if (added != null) { + added_photos = new Gee.ArrayList<Photo>(); + foreach (DataView view in added) { + Photo photo = (Photo) view.get_source(); + + if (photo_id_list != null) + assert(!photo_id_list.contains(photo.get_photo_id())); + + bool is_added = added_photos.add(photo); + assert(is_added); + } + } + + Gee.Collection<Photo> removed_photos = null; + if (removed != null) { + assert(photo_id_list != null); + + removed_photos = new Gee.ArrayList<Photo>(); + foreach (DataView view in removed) { + Photo photo = (Photo) view.get_source(); + + assert(photo_id_list.contains(photo.get_photo_id())); + + bool is_added = removed_photos.add(photo); + assert(is_added); + } + } + + if (removed_photos != null) + foreach (Photo photo in removed_photos) + FaceLocation.destroy(get_face_id(), photo.get_photo_id()); + + // notify of changes to this face + if (added_photos != null) + global.notify_container_contents_added(this, added_photos, relinking); + + if (removed_photos != null) + global.notify_container_contents_removed(this, removed_photos, unlinking); + + if (added_photos != null || removed_photos != null) { + global.notify_container_contents_altered(this, added_photos, relinking, removed_photos, + unlinking); + } + + // if no more sources, face evaporates; do not touch "this" afterwards + if (media_views.get_count() == 0) + global.evaporate(this); + } + + private void on_sources_destroyed(Gee.Collection<DataSource> sources) { + detach_many((Gee.Collection<MediaSource>) sources); + } + + public override void destroy() { + // detach all remaining sources from the face, so observers are informed ... need to detach + // the contents_altered handler because it will destroy this object when sources is empty, + // which is bad reentrancy mojo (but hook it back up for the dtor's sake) + if (media_views.get_count() > 0) { + media_views.contents_altered.disconnect(on_media_views_contents_altered); + + Gee.ArrayList<MediaSource> removed = new Gee.ArrayList<MediaSource>(); + removed.add_all((Gee.Collection<MediaSource>) media_views.get_sources()); + + media_views.clear(); + + global.notify_container_contents_removed(this, removed, false); + global.notify_container_contents_altered(this, null, false, removed, false); + + media_views.contents_altered.connect(on_media_views_contents_altered); + } + + try { + FaceTable.get_instance().remove(row.face_id); + } catch (DatabaseError err) { + AppWindow.database_error(err); + } + + base.destroy(); + } +} + +#endif |