Show Blog Invitations

This refactors the forum invitation code,
so it can be used by both: forums and blogs.

briar-android/src/org/briarproject/android/sharing/BlogInvitationAdapter.java

@@ -0,0 +1,37 @@
+package org.briarproject.android.sharing;
+
+import android.content.Context;
+
+import org.briarproject.R;
+import org.briarproject.api.blogs.Blog;
+
+class BlogInvitationAdapter extends InvitationAdapter {
+
+	BlogInvitationAdapter(Context ctx, AvailableForumClickListener listener) {
+		super(ctx, listener);
+	}
+
+	@Override
+	public void onBindViewHolder(InvitationsViewHolder ui, int position) {
+		super.onBindViewHolder(ui, position);
+		InvitationItem item = getItem(position);
+		Blog blog = (Blog) item.getShareable();
+
+		ui.avatar.setAuthorAvatar(blog.getAuthor());
+
+		ui.name.setText(ctx.getString(R.string.blogs_personal_blog,
+				blog.getAuthor().getName()));
+
+		if (item.isSubscribed()) {
+			ui.subscribed.setText(ctx.getString(R.string.blogs_sharing_exists,
+					blog.getAuthor().getName()));
+		}
+	}
+
+	int compareInvitations(InvitationItem o1, InvitationItem o2) {
+		return String.CASE_INSENSITIVE_ORDER
+				.compare(((Blog) o1.getShareable()).getAuthor().getName(),
+						((Blog) o2.getShareable()).getAuthor().getName());
+	}
+
+}

briar-android/src/org/briarproject/android/sharing/ForumInvitationAdapter.java

@@ -0,0 +1,31 @@
+package org.briarproject.android.sharing;
+
+import android.content.Context;
+
+import org.briarproject.api.forum.Forum;
+
+class ForumInvitationAdapter extends InvitationAdapter {
+
+	ForumInvitationAdapter(Context ctx, AvailableForumClickListener listener) {
+		super(ctx, listener);
+	}
+
+	@Override
+	public void onBindViewHolder(InvitationsViewHolder ui, int position) {
+		super.onBindViewHolder(ui, position);
+		InvitationItem item = getItem(position);
+		Forum forum = (Forum) item.getShareable();
+
+		ui.avatar.setText(forum.getName().substring(0, 1));
+		ui.avatar.setBackgroundBytes(item.getShareable().getId().getBytes());
+
+		ui.name.setText(forum.getName());
+	}
+
+	int compareInvitations(InvitationItem o1, InvitationItem o2) {
+		return String.CASE_INSENSITIVE_ORDER
+				.compare(((Forum) o1.getShareable()).getName(),
+						((Forum) o2.getShareable()).getName());
+	}
+
+}

briar-android/src/org/briarproject/android/sharing/InvitationAdapter.java

@@ -0,0 +1,170 @@
+package org.briarproject.android.sharing;
+
+import android.content.Context;
+import android.support.v7.util.SortedList;
+import android.support.v7.widget.RecyclerView;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.Button;
+import android.widget.TextView;
+
+import org.briarproject.R;
+import org.briarproject.android.util.TextAvatarView;
+import org.briarproject.api.contact.Contact;
+import org.briarproject.util.StringUtils;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+import static android.view.View.GONE;
+import static android.view.View.VISIBLE;
+
+abstract class InvitationAdapter extends
+		RecyclerView.Adapter<InvitationAdapter.InvitationsViewHolder> {
+
+	protected final Context ctx;
+	private final AvailableForumClickListener listener;
+	private final SortedList<InvitationItem> invitations =
+			new SortedList<>(InvitationItem.class,
+					new SortedListCallBacks());
+
+	InvitationAdapter(Context ctx, AvailableForumClickListener listener) {
+		this.ctx = ctx;
+		this.listener = listener;
+	}
+
+	@Override
+	public InvitationsViewHolder onCreateViewHolder(ViewGroup parent,
+			int viewType) {
+
+		View v = LayoutInflater.from(ctx)
+				.inflate(R.layout.list_item_invitations, parent,  false);
+		return new InvitationsViewHolder(v);
+	}
+
+	@Override
+	public void onBindViewHolder(InvitationsViewHolder ui, int position) {
+		final InvitationItem item = getItem(position);
+
+		Collection<String> names = new ArrayList<>();
+		for (Contact c : item.getContacts()) names.add(c.getAuthor().getName());
+		ui.sharedBy.setText(ctx.getString(R.string.shared_by_format,
+				StringUtils.join(names, ", ")));
+
+		if (item.isSubscribed()) {
+			ui.subscribed.setVisibility(VISIBLE);
+		} else {
+			ui.subscribed.setVisibility(GONE);
+		}
+
+		ui.accept.setOnClickListener(new View.OnClickListener() {
+			@Override
+			public void onClick(View v) {
+				listener.onItemClick(item, true);
+			}
+		});
+		ui.decline.setOnClickListener(new View.OnClickListener() {
+			@Override
+			public void onClick(View v) {
+				listener.onItemClick(item, false);
+			}
+		});
+	}
+
+	@Override
+	public int getItemCount() {
+		return invitations.size();
+	}
+
+	public InvitationItem getItem(int position) {
+		return invitations.get(position);
+	}
+
+	public void add(InvitationItem item) {
+		invitations.add(item);
+	}
+
+	public void addAll(Collection<InvitationItem> list) {
+		invitations.addAll(list);
+	}
+
+	public void remove(InvitationItem item) {
+		invitations.remove(item);
+	}
+
+	public void clear() {
+		invitations.clear();
+	}
+
+	static class InvitationsViewHolder extends RecyclerView.ViewHolder {
+
+		final TextAvatarView avatar;
+		final TextView name;
+		final TextView sharedBy;
+		final TextView subscribed;
+		final Button accept;
+		final Button decline;
+
+		InvitationsViewHolder(View v) {
+			super(v);
+
+			avatar = (TextAvatarView) v.findViewById(R.id.avatarView);
+			name = (TextView) v.findViewById(R.id.forumNameView);
+			sharedBy = (TextView) v.findViewById(R.id.sharedByView);
+			subscribed = (TextView) v.findViewById(R.id.forumSubscribedView);
+			accept = (Button) v.findViewById(R.id.acceptButton);
+			decline = (Button) v.findViewById(R.id.declineButton);
+		}
+	}
+
+	abstract int compareInvitations(InvitationItem o1, InvitationItem o2);
+
+	private class SortedListCallBacks
+			extends SortedList.Callback<InvitationItem> {
+
+		@Override
+		public int compare(InvitationItem o1,
+				InvitationItem o2) {
+			return compareInvitations(o1, o2);
+		}
+
+		@Override
+		public void onInserted(int position, int count) {
+			notifyItemRangeInserted(position, count);
+		}
+
+		@Override
+		public void onRemoved(int position, int count) {
+			notifyItemRangeRemoved(position, count);
+		}
+
+		@Override
+		public void onMoved(int fromPosition, int toPosition) {
+			notifyItemMoved(fromPosition, toPosition);
+		}
+
+		@Override
+		public void onChanged(int position, int count) {
+			notifyItemRangeChanged(position, count);
+		}
+
+		@Override
+		public boolean areContentsTheSame(InvitationItem oldItem,
+				InvitationItem newItem) {
+			return oldItem.isSubscribed() == newItem.isSubscribed() &&
+					oldItem.getContacts().equals(newItem.getContacts());
+		}
+
+		@Override
+		public boolean areItemsTheSame(InvitationItem oldItem,
+				InvitationItem newItem) {
+			return oldItem.getShareable().equals(newItem.getShareable());
+		}
+	}
+
+
+	interface AvailableForumClickListener {
+		void onItemClick(InvitationItem item, boolean accept);
+	}
+}

briar-android/src/org/briarproject/android/sharing/InvitationItem.java

@@ -0,0 +1,33 @@
+package org.briarproject.android.sharing;
+
+import org.briarproject.api.contact.Contact;
+import org.briarproject.api.sharing.Shareable;
+
+import java.util.Collection;
+
+class InvitationItem {
+
+	private final Shareable shareable;
+	private final boolean subscribed;
+	private final Collection<Contact> contacts;
+
+	InvitationItem(Shareable shareable, boolean subscribed,
+			Collection<Contact> contacts) {
+
+		this.shareable = shareable;
+		this.subscribed = subscribed;
+		this.contacts = contacts;
+	}
+
+	Shareable getShareable() {
+		return shareable;
+	}
+
+	boolean isSubscribed() {
+		return subscribed;
+	}
+
+	Collection<Contact> getContacts() {
+		return contacts;
+	}
+}

briar-android/src/org/briarproject/android/sharing/InvitationsActivity.java

@@ -0,0 +1,308 @@
+package org.briarproject.android.sharing;
+
+import android.content.Intent;
+import android.os.Bundle;
+import android.support.v7.widget.LinearLayoutManager;
+import android.widget.Toast;
+
+import org.briarproject.R;
+import org.briarproject.android.ActivityComponent;
+import org.briarproject.android.BriarActivity;
+import org.briarproject.android.util.BriarRecyclerView;
+import org.briarproject.api.blogs.Blog;
+import org.briarproject.api.blogs.BlogManager;
+import org.briarproject.api.blogs.BlogSharingManager;
+import org.briarproject.api.contact.Contact;
+import org.briarproject.api.db.DbException;
+import org.briarproject.api.db.NoSuchGroupException;
+import org.briarproject.api.event.BlogInvitationReceivedEvent;
+import org.briarproject.api.event.ContactRemovedEvent;
+import org.briarproject.api.event.Event;
+import org.briarproject.api.event.EventBus;
+import org.briarproject.api.event.EventListener;
+import org.briarproject.api.event.ForumInvitationReceivedEvent;
+import org.briarproject.api.event.GroupAddedEvent;
+import org.briarproject.api.event.GroupRemovedEvent;
+import org.briarproject.api.event.InvitationReceivedEvent;
+import org.briarproject.api.forum.Forum;
+import org.briarproject.api.forum.ForumManager;
+import org.briarproject.api.forum.ForumSharingManager;
+import org.briarproject.api.sync.ClientId;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.logging.Logger;
+
+import javax.inject.Inject;
+
+import static android.widget.Toast.LENGTH_SHORT;
+import static java.util.logging.Level.INFO;
+import static java.util.logging.Level.WARNING;
+import static org.briarproject.android.sharing.InvitationAdapter.AvailableForumClickListener;
+import static org.briarproject.android.sharing.ShareActivity.BLOG;
+import static org.briarproject.android.sharing.ShareActivity.FORUM;
+import static org.briarproject.android.sharing.ShareActivity.SHAREABLE;
+
+public class InvitationsActivity extends BriarActivity
+		implements EventListener, AvailableForumClickListener {
+
+	private static final Logger LOG =
+			Logger.getLogger(InvitationsActivity.class.getName());
+
+	private int shareable;
+	private InvitationAdapter adapter;
+
+	// Fields that are accessed from background threads must be volatile
+	@Inject
+	protected volatile ForumManager forumManager;
+	@Inject
+	protected volatile ForumSharingManager forumSharingManager;
+	@Inject
+	protected volatile BlogManager blogManager;
+	@Inject
+	protected volatile BlogSharingManager blogSharingManager;
+	@Inject
+	protected volatile EventBus eventBus;
+
+	@Override
+	public void onCreate(Bundle state) {
+		super.onCreate(state);
+
+		setContentView(R.layout.activity_invitations);
+
+		Intent i = getIntent();
+		shareable = i.getIntExtra(SHAREABLE, 0);
+		if (shareable == 0) throw new IllegalStateException("No Shareable");
+
+		if (shareable == FORUM) {
+			adapter = new ForumInvitationAdapter(this, this);
+		} else if (shareable == BLOG) {
+			adapter = new BlogInvitationAdapter(this, this);
+			setTitle(getString(R.string.blogs_sharing_invitations_title));
+		} else {
+			throw new IllegalArgumentException("Unknown Shareable Type");
+		}
+
+		BriarRecyclerView list =
+				(BriarRecyclerView) findViewById(R.id.invitationsView);
+		if (list != null) {
+			list.setLayoutManager(new LinearLayoutManager(this));
+			list.setAdapter(adapter);
+		}
+	}
+
+	@Override
+	public void injectActivity(ActivityComponent component) {
+		component.inject(this);
+	}
+
+	@Override
+	public void onResume() {
+		super.onResume();
+		eventBus.addListener(this);
+		loadShareables(false);
+	}
+
+	@Override
+	public void onPause() {
+		super.onPause();
+		eventBus.removeListener(this);
+		adapter.clear();
+	}
+
+	private void loadShareables(boolean clear) {
+		if (shareable == FORUM) {
+			loadForums(clear);
+		} else if (shareable == BLOG) {
+			loadBlogs(clear);
+		}
+	}
+
+	private void loadForums(final boolean clear) {
+		runOnDbThread(new Runnable() {
+			@Override
+			public void run() {
+				try {
+					Collection<InvitationItem> forums = new ArrayList<>();
+					long now = System.currentTimeMillis();
+					for (Forum f : forumSharingManager.getInvited()) {
+						boolean subscribed;
+						try {
+							forumManager.getForum(f.getId());
+							subscribed = true;
+						} catch (NoSuchGroupException e) {
+							subscribed = false;
+						}
+						Collection<Contact> c =
+								forumSharingManager.getSharedBy(f.getId());
+						forums.add(
+								new InvitationItem(f, subscribed, c));
+					}
+					long duration = System.currentTimeMillis() - now;
+					if (LOG.isLoggable(INFO))
+						LOG.info("Load took " + duration + " ms");
+					displayInvitations(forums, clear);
+				} catch (DbException e) {
+					if (LOG.isLoggable(WARNING))
+						LOG.log(WARNING, e.toString(), e);
+				}
+			}
+		});
+	}
+
+	private void loadBlogs(final boolean clear) {
+		runOnDbThread(new Runnable() {
+			@Override
+			public void run() {
+				try {
+					Collection<InvitationItem> invitations = new ArrayList<>();
+					long now = System.currentTimeMillis();
+					for (Blog b : blogSharingManager.getInvited()) {
+						boolean subscribed;
+						try {
+							blogManager.getBlog(b.getId());
+							subscribed = true;
+						} catch (NoSuchGroupException e) {
+							subscribed = false;
+						}
+						Collection<Contact> c =
+								blogSharingManager.getSharedBy(b.getId());
+						invitations.add(
+								new InvitationItem(b, subscribed, c));
+					}
+					long duration = System.currentTimeMillis() - now;
+					if (LOG.isLoggable(INFO))
+						LOG.info("Load took " + duration + " ms");
+					displayInvitations(invitations, clear);
+				} catch (DbException e) {
+					if (LOG.isLoggable(WARNING))
+						LOG.log(WARNING, e.toString(), e);
+				}
+			}
+		});
+	}
+
+	private void displayInvitations(final Collection<InvitationItem> invitations,
+			final boolean clear) {
+		runOnUiThread(new Runnable() {
+			@Override
+			public void run() {
+				if (invitations.isEmpty()) {
+					LOG.info("No more invitations available, finishing");
+					finish();
+				} else {
+					if (clear) adapter.clear();
+					adapter.addAll(invitations);
+				}
+			}
+		});
+	}
+
+	@Override
+	public void eventOccurred(Event e) {
+		if (e instanceof ContactRemovedEvent) {
+			LOG.info("Contact removed, reloading");
+			loadShareables(true);
+		} else if (e instanceof GroupAddedEvent) {
+			GroupAddedEvent g = (GroupAddedEvent) e;
+			ClientId cId = g.getGroup().getClientId();
+			if (cId.equals(forumManager.getClientId()) && shareable == FORUM) {
+				LOG.info("Forum added, reloading");
+				loadShareables(false);
+			} else if (cId.equals(blogManager.getClientId()) &&
+					shareable == BLOG) {
+				LOG.info("Blog added, reloading");
+				loadShareables(true);
+			}
+		} else if (e instanceof GroupRemovedEvent) {
+			GroupRemovedEvent g = (GroupRemovedEvent) e;
+			ClientId cId = g.getGroup().getClientId();
+			if (cId.equals(forumManager.getClientId()) && shareable == FORUM) {
+				LOG.info("Forum removed, reloading");
+				loadShareables(true);
+			} else if (cId.equals(blogManager.getClientId()) &&
+					shareable == BLOG) {
+				LOG.info("Blog removed, reloading");
+				loadShareables(true);
+			}
+		} else if (e instanceof InvitationReceivedEvent) {
+			if (e instanceof ForumInvitationReceivedEvent &&
+					shareable == FORUM) {
+				LOG.info("Forum invitation received, reloading");
+				loadShareables(false);
+			} else if (e instanceof BlogInvitationReceivedEvent &&
+					shareable == BLOG) {
+				LOG.info("Blog invitation received, reloading");
+				loadShareables(false);
+			}
+		}
+	}
+
+	@Override
+	public void onItemClick(InvitationItem item, boolean accept) {
+		respondToInvitation(item, accept);
+
+		// show toast
+		int res;
+		if (shareable == FORUM) {
+			res = R.string.forum_declined_toast;
+			if (accept) res = R.string.forum_joined_toast;
+		} else {
+			res = R.string.blogs_sharing_declined_toast;
+			if (accept) res = R.string.blogs_sharing_joined_toast;
+		}
+		Toast.makeText(this, res, LENGTH_SHORT).show();
+
+		// remove item and finish if it was the last
+		adapter.remove(item);
+		if (adapter.getItemCount() == 0) {
+			supportFinishAfterTransition();
+		}
+	}
+
+	private void respondToInvitation(final InvitationItem item,
+			final boolean accept) {
+
+		if (shareable == FORUM) {
+			respondToForumInvitation(item, accept);
+		} else if (shareable == BLOG) {
+			respondToBlogInvitation(item, accept);
+		}
+	}
+
+	private void respondToForumInvitation(final InvitationItem item,
+			final boolean accept) {
+		runOnDbThread(new Runnable() {
+			@Override
+			public void run() {
+				try {
+					Forum f = (Forum) item.getShareable();
+					for (Contact c : item.getContacts()) {
+						forumSharingManager.respondToInvitation(f, c, accept);
+					}
+				} catch (DbException e) {
+					if (LOG.isLoggable(WARNING))
+						LOG.log(WARNING, e.toString(), e);
+				}
+			}
+		});
+	}
+
+	private void respondToBlogInvitation(final InvitationItem item,
+			final boolean accept) {
+		runOnDbThread(new Runnable() {
+			@Override
+			public void run() {
+				try {
+					Blog b = (Blog) item.getShareable();
+					for (Contact c : item.getContacts()) {
+						blogSharingManager.respondToInvitation(b, c, accept);
+					}
+				} catch (DbException e) {
+					if (LOG.isLoggable(WARNING))
+						LOG.log(WARNING, e.toString(), e);
+				}
+			}
+		});
+	}
+}