Merge branch 'master' into fdroid

# Conflicts:
#	.gitlab-ci.yml
#	.magnum.yml
#	app/build.gradle
#	app/src/main/AndroidManifest.xml
#	app/src/main/java/com/commit451/gitlab/GitLabApp.java

app/src/main/java/com/commit451/gitlab/events/ReloadDataEvent.java → app/src/main/java/com/commit451/gitlab/event/ReloadDataEvent.java

-package com.commit451.gitlab.events;
+package com.commit451.gitlab.event;
 /**
  * Signifies that the fragments should reload their data

app/src/main/java/com/commit451/gitlab/events/UserAddedEvent.java

-package com.commit451.gitlab.events;
-
-import com.commit451.gitlab.model.User;
-
-/**
- * Indicates that a user was added
- * Created by Jawn on 9/17/2015.
- */
-public class UserAddedEvent {
-
-    public User user;
-    public UserAddedEvent(User user) {
-        this.user = user;
-    }
-}

app/src/main/java/com/commit451/gitlab/fragments/BaseFragment.java → app/src/main/java/com/commit451/gitlab/fragment/BaseFragment.java

-package com.commit451.gitlab.fragments;
+package com.commit451.gitlab.fragment;
+
+import com.commit451.gitlab.GitLabApp;
+import com.commit451.gitlab.event.ReloadDataEvent;
+import com.squareup.otto.Subscribe;
 import android.os.Bundle;
 import android.support.v4.app.Fragment;
 import android.view.View;
-import com.commit451.gitlab.GitLabApp;
-import com.commit451.gitlab.events.ReloadDataEvent;
-import com.squareup.otto.Subscribe;
-
-/**
- * Created by Jawn on 9/1/2015.
- */
 public class BaseFragment extends Fragment{
-    EventReceiver mBaseEventReceiever;
-
-    @Override
-    public void onCreate(Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-        mBaseEventReceiever = new EventReceiver();
-    }
+    private EventReceiver mBaseEventReceiever;
     @Override
     public void onViewCreated(View view, Bundle savedInstanceState) {
         super.onViewCreated(view, savedInstanceState);
+
+        mBaseEventReceiever = new EventReceiver();
         GitLabApp.bus().register(mBaseEventReceiever);
     }
@@ -34,11 +27,13 @@ public class BaseFragment extends Fragment{
     }
     protected void loadData() {
-        //Override this
     }
-    private class EventReceiver {
+    public boolean onBackPressed() {
+        return false;
+    }
+    private class EventReceiver {
         @Subscribe
         public void onReloadData(ReloadDataEvent event) {
             loadData();

app/src/main/java/com/commit451/gitlab/fragment/CommitsFragment.java

+package com.commit451.gitlab.fragment;
+
+import android.os.Bundle;
+import android.support.v4.widget.SwipeRefreshLayout;
+import android.support.v7.widget.LinearLayoutManager;
+import android.support.v7.widget.RecyclerView;
+import android.text.TextUtils;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.TextView;
+
+import com.commit451.gitlab.GitLabApp;
+import com.commit451.gitlab.R;
+import com.commit451.gitlab.activity.DiffActivity;
+import com.commit451.gitlab.activity.ProjectActivity;
+import com.commit451.gitlab.adapter.CommitsAdapter;
+import com.commit451.gitlab.api.GitLabClient;
+import com.commit451.gitlab.event.ProjectReloadEvent;
+import com.commit451.gitlab.model.api.Project;
+import com.commit451.gitlab.model.api.RepositoryCommit;
+import com.squareup.otto.Subscribe;
+
+import java.util.List;
+
+import butterknife.Bind;
+import butterknife.ButterKnife;
+import retrofit.Callback;
+import retrofit.Response;
+import retrofit.Retrofit;
+import timber.log.Timber;
+
+public class CommitsFragment extends BaseFragment {
+
+    public static CommitsFragment newInstance() {
+        return new CommitsFragment();
+    }
+
+    @Bind(R.id.swipe_layout) SwipeRefreshLayout mSwipeRefreshLayout;
+    @Bind(R.id.list) RecyclerView mCommitsListView;
+    @Bind(R.id.message_text) TextView mMessageView;
+
+    private Project mProject;
+    private String mBranchName;
+    private EventReceiver mEventReceiver;
+    private LinearLayoutManager mCommitsLayoutManager;
+    private CommitsAdapter mCommitsAdapter;
+    private int mPage = -1;
+    private boolean mLoading = false;
+
+    private final RecyclerView.OnScrollListener mOnScrollListener = new RecyclerView.OnScrollListener() {
+        @Override
+        public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
+            super.onScrolled(recyclerView, dx, dy);
+            int visibleItemCount = mCommitsLayoutManager.getChildCount();
+            int totalItemCount = mCommitsLayoutManager.getItemCount();
+            int firstVisibleItem = mCommitsLayoutManager.findFirstVisibleItemPosition();
+            if (firstVisibleItem + visibleItemCount >= totalItemCount && !mLoading && mPage >= 0) {
+                loadMore();
+            }
+        }
+    };
+
+    private final Callback<List<RepositoryCommit>> mCommitsCallback = new Callback<List<RepositoryCommit>>() {
+        @Override
+        public void onResponse(Response<List<RepositoryCommit>> response, Retrofit retrofit) {
+            mLoading = false;
+            if (getView() == null) {
+                return;
+            }
+
+            mSwipeRefreshLayout.setRefreshing(false);
+
+            if (!response.isSuccess()) {
+                Timber.e("Commits response was not a success: %d", response.code());
+                mMessageView.setVisibility(View.VISIBLE);
+                mMessageView.setText(R.string.connection_error_commits);
+                mCommitsAdapter.setData(null);
+                mPage = 0;
+                return;
+            }
+
+            if (!response.body().isEmpty()) {
+                mMessageView.setVisibility(View.GONE);
+            } else if (mPage <= 0) {
+                Timber.d("No commits have been made");
+                mMessageView.setVisibility(View.VISIBLE);
+                mMessageView.setText(R.string.no_commits_found);
+            }
+
+            mCommitsAdapter.setData(response.body());
+
+            if (response.body().isEmpty()) {
+                mPage = -1;
+            }
+        }
+
+        @Override
+        public void onFailure(Throwable t) {
+            mLoading = false;
+            Timber.e(t, null);
+
+            if (getView() == null) {
+                return;
+            }
+
+            mSwipeRefreshLayout.setRefreshing(false);
+
+            mMessageView.setVisibility(View.VISIBLE);
+            mMessageView.setText(R.string.connection_error);
+            mCommitsAdapter.setData(null);
+            mPage = -1;
+        }
+    };
+
+    private final Callback<List<RepositoryCommit>> mMoreCommitsCallback = new Callback<List<RepositoryCommit>>() {
+        @Override
+        public void onResponse(Response<List<RepositoryCommit>> response, Retrofit retrofit) {
+            if (!response.isSuccess()) {
+                return;
+            }
+            mLoading = false;
+            mCommitsAdapter.setLoading(false);
+            mPage++;
+            mCommitsAdapter.addData(response.body());
+        }
+
+        @Override
+        public void onFailure(Throwable t) {
+            Timber.e(t, null);
+            mCommitsAdapter.setLoading(false);
+            mLoading = false;
+        }
+    };
+
+    private final CommitsAdapter.Listener mCommitsAdapterListener = new CommitsAdapter.Listener() {
+        @Override
+        public void onCommitClicked(RepositoryCommit commit) {
+            getActivity().startActivity(DiffActivity.newInstance(getActivity(), mProject, commit));
+        }
+    };
+
+    @Override
+    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+        return inflater.inflate(R.layout.fragment_commits, container, false);
+    }
+
+    @Override
+    public void onViewCreated(View view, Bundle savedInstanceState) {
+        super.onViewCreated(view, savedInstanceState);
+        ButterKnife.bind(this, view);
+
+        mEventReceiver = new EventReceiver();
+        GitLabApp.bus().register(mEventReceiver);
+
+        mCommitsAdapter = new CommitsAdapter(mCommitsAdapterListener);
+        mCommitsLayoutManager = new LinearLayoutManager(getActivity());
+        mCommitsListView.setLayoutManager(mCommitsLayoutManager);
+        mCommitsListView.setAdapter(mCommitsAdapter);
+        mCommitsListView.addOnScrollListener(mOnScrollListener);
+
+        mSwipeRefreshLayout.setOnRefreshListener(new SwipeRefreshLayout.OnRefreshListener() {
+            @Override
+            public void onRefresh() {
+                loadData();
+            }
+        });
+
+        if (getActivity() instanceof ProjectActivity) {
+            mProject = ((ProjectActivity) getActivity()).getProject();
+            mBranchName = ((ProjectActivity) getActivity()).getBranchName();
+            loadData();
+        } else {
+            throw new IllegalStateException("Incorrect parent activity");
+        }
+    }
+
+    @Override
+    public void onDestroyView() {
+        super.onDestroyView();
+        ButterKnife.unbind(this);
+        GitLabApp.bus().unregister(mEventReceiver);
+    }
+
+    @Override
+    protected void loadData() {
+        if (getView() == null) {
+            return;
+        }
+
+        if (mProject == null || TextUtils.isEmpty(mBranchName)) {
+            mSwipeRefreshLayout.setRefreshing(false);
+            return;
+        }
+
+        mSwipeRefreshLayout.post(new Runnable() {
+            @Override
+            public void run() {
+                if (mSwipeRefreshLayout != null) {
+                    mSwipeRefreshLayout.setRefreshing(true);
+                }
+            }
+        });
+
+        mPage = 0;
+        mLoading = true;
+
+        GitLabClient.instance().getCommits(mProject.getId(), mBranchName, mPage).enqueue(mCommitsCallback);
+    }
+
+    private void loadMore() {
+        if (getView() == null) {
+            return;
+        }
+
+        if (mProject == null || TextUtils.isEmpty(mBranchName) || mPage < 0) {
+            return;
+        }
+
+        mPage++;
+        mLoading = true;
+        mCommitsAdapter.setLoading(true);
+
+        Timber.d("loadMore called for " + mPage);
+        GitLabClient.instance().getCommits(mProject.getId(), mBranchName, mPage).enqueue(mMoreCommitsCallback);
+    }
+
+    private class EventReceiver {
+        @Subscribe
+        public void onProjectReload(ProjectReloadEvent event) {
+            mProject = event.mProject;
+            mBranchName = event.mBranchName;
+            loadData();
+        }
+    }
+}
\ No newline at end of file

app/src/main/java/com/commit451/gitlab/fragment/FeedFragment.java

+package com.commit451.gitlab.fragment;
+
+import com.commit451.gitlab.GitLabApp;
+import com.commit451.gitlab.R;
+import com.commit451.gitlab.adapter.FeedAdapter;
+import com.commit451.gitlab.api.GitLabClient;
+import com.commit451.gitlab.model.rss.Entry;
+import com.commit451.gitlab.model.rss.Feed;
+import com.commit451.gitlab.util.IntentUtil;
+
+import android.os.Bundle;
+import android.support.v4.widget.SwipeRefreshLayout;
+import android.support.v7.widget.LinearLayoutManager;
+import android.support.v7.widget.RecyclerView;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.TextView;
+
+import butterknife.Bind;
+import butterknife.ButterKnife;
+import retrofit.Callback;
+import retrofit.Response;
+import retrofit.Retrofit;
+import timber.log.Timber;
+
+public class FeedFragment extends BaseFragment {
+
+    private static final String EXTRA_FEED_URL = "extra_feed_url";
+
+    public static FeedFragment newInstance(String feedUrl) {
+        Bundle args = new Bundle();
+        args.putString(EXTRA_FEED_URL, feedUrl);
+
+        FeedFragment fragment = new FeedFragment();
+        fragment.setArguments(args);
+        return fragment;
+    }
+
+    @Bind(R.id.swipe_layout) SwipeRefreshLayout mSwipeRefreshLayout;
+    @Bind(R.id.list) RecyclerView mEntryListView;
+    @Bind(R.id.message_text) TextView mMessageView;
+
+    private String mFeedUrl;
+    private EventReceiver mEventReceiver;
+    private FeedAdapter mFeedAdapter;
+
+    private final Callback<Feed> mUserFeedCallback = new Callback<Feed>() {
+        @Override
+        public void onResponse(Response<Feed> response, Retrofit retrofit) {
+            if (getView() == null) {
+                return;
+            }
+
+            mSwipeRefreshLayout.setRefreshing(false);
+
+            if (!response.isSuccess()) {
+                Timber.e("Feed response was not a success: %d", response.code());
+                mMessageView.setVisibility(View.VISIBLE);
+                mMessageView.setText(R.string.connection_error_feed);
+                mFeedAdapter.setEntries(null);
+                return;
+            }
+
+            if (response.body().getEntries() != null && !response.body().getEntries().isEmpty()) {
+                mMessageView.setVisibility(View.GONE);
+            } else {
+                Timber.d("No activity in the feed");
+                mMessageView.setVisibility(View.VISIBLE);
+                mMessageView.setText(R.string.no_activity);
+            }
+
+            mFeedAdapter.setEntries(response.body().getEntries());
+        }
+
+        @Override
+        public void onFailure(Throwable t) {
+            Timber.e(t, null);
+
+            if (getView() == null) {
+                return;
+            }
+
+            mSwipeRefreshLayout.setRefreshing(false);
+
+            mMessageView.setVisibility(View.VISIBLE);
+            mMessageView.setText(R.string.connection_error);
+            mFeedAdapter.setEntries(null);
+        }
+    };
+
+    private final FeedAdapter.Listener mFeedAdapterListener = new FeedAdapter.Listener() {
+        @Override
+        public void onFeedEntryClicked(Entry entry) {
+            IntentUtil.openPage(getActivity().getWindow().getDecorView(), entry.getLink().getHref());
+        }
+    };
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        mFeedUrl = getArguments().getString(EXTRA_FEED_URL);
+    }
+
+    @Override
+    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+        return inflater.inflate(R.layout.fragment_feed, container, false);
+    }
+
+    @Override
+    public void onViewCreated(View view, Bundle savedInstanceState) {
+        super.onViewCreated(view, savedInstanceState);
+        ButterKnife.bind(this, view);
+
+        mEventReceiver = new EventReceiver();
+        GitLabApp.bus().register(mEventReceiver);
+
+        mFeedAdapter = new FeedAdapter(mFeedAdapterListener);
+        mEntryListView.setLayoutManager(new LinearLayoutManager(getActivity()));
+        mEntryListView.setAdapter(mFeedAdapter);
+
+        mSwipeRefreshLayout.setOnRefreshListener(new SwipeRefreshLayout.OnRefreshListener() {
+            @Override
+            public void onRefresh() {
+                loadData();
+            }
+        });
+
+        loadData();
+    }
+
+    @Override
+    public void onDestroyView() {
+        super.onDestroyView();
+        ButterKnife.unbind(this);
+        GitLabApp.bus().unregister(mEventReceiver);
+    }
+
+    @Override
+    protected void loadData() {
+        if (getView() == null) {
+            return;
+        }
+
+        if (mFeedUrl == null) {
+            mSwipeRefreshLayout.setRefreshing(false);
+            return;
+        }
+
+        mSwipeRefreshLayout.post(new Runnable() {
+            @Override
+            public void run() {
+                if (mSwipeRefreshLayout != null) {
+                    mSwipeRefreshLayout.setRefreshing(true);
+                }
+            }
+        });
+
+        GitLabClient.rssInstance().getFeed(mFeedUrl).enqueue(mUserFeedCallback);
+    }
+
+    private class EventReceiver {
+    }
+}

app/src/main/java/com/commit451/gitlab/fragments/FilesFragment.java → app/src/main/java/com/commit451/gitlab/fragment/FilesFragment.java

-package com.commit451.gitlab.fragments;
+package com.commit451.gitlab.fragment;
 import android.content.ClipData;
 import android.content.ClipboardManager;
 import android.content.Context;
 import android.os.Bundle;
-import android.support.design.widget.Snackbar;
 import android.support.v4.widget.SwipeRefreshLayout;
 import android.support.v7.widget.LinearLayoutManager;
 import android.support.v7.widget.RecyclerView;
@@ -17,17 +16,18 @@ import android.widget.Toast;
 import com.commit451.gitlab.GitLabApp;
 import com.commit451.gitlab.R;
-import com.commit451.gitlab.activities.ProjectActivity;
+import com.commit451.gitlab.activity.ProjectActivity;
 import com.commit451.gitlab.adapter.BreadcrumbAdapter;
 import com.commit451.gitlab.adapter.FilesAdapter;
 import com.commit451.gitlab.api.GitLabClient;
-import com.commit451.gitlab.events.ProjectReloadEvent;
-import com.commit451.gitlab.model.Project;
-import com.commit451.gitlab.model.TreeItem;
-import com.commit451.gitlab.tools.IntentUtil;
-import com.commit451.gitlab.tools.NavigationManager;
+import com.commit451.gitlab.event.ProjectReloadEvent;
+import com.commit451.gitlab.model.api.Project;
+import com.commit451.gitlab.model.api.RepositoryTreeObject;
+import com.commit451.gitlab.util.IntentUtil;
+import com.commit451.gitlab.util.NavigationManager;
 import com.squareup.otto.Subscribe;
+import java.util.ArrayList;
 import java.util.List;
 import butterknife.Bind;
@@ -39,121 +39,135 @@ import timber.log.Timber;
 public class FilesFragment extends BaseFragment {
-	public static FilesFragment newInstance() {
-		Bundle args = new Bundle();
-		FilesFragment fragment = new FilesFragment();
-		fragment.setArguments(args);
-		return fragment;
-	}
-	@Bind(R.id.error_text) TextView mErrorText;
+    public static FilesFragment newInstance() {
+        return new FilesFragment();
+    }
     @Bind(R.id.swipe_layout) SwipeRefreshLayout mSwipeRefreshLayout;
-	@Bind(R.id.list) RecyclerView mFilesList;
-	@Bind(R.id.breadcrumb) RecyclerView mBreadcrumbList;
-	EventReceiver mEventReceiver;
-    Project mProject;
-    String mBranchName;
-    FilesAdapter mFilesAdapter;
-    BreadcrumbAdapter mBreadcrumbAdapter;
-    private BreadcrumbAdapter.Listener mBreadcrumbAdapterListener = new BreadcrumbAdapter.Listener() {
+    @Bind(R.id.list) RecyclerView mFilesListView;
+    @Bind(R.id.breadcrumb) RecyclerView mBreadcrumbListView;
+    @Bind(R.id.message_text) TextView mMessageView;
+
+    private Project mProject;
+    private String mBranchName;
+    private EventReceiver mEventReceiver;
+    private FilesAdapter mFilesAdapter;
+    private BreadcrumbAdapter mBreadcrumbAdapter;
+    private String mCurrentPath = "";
+
+    private class FilesCallback implements Callback<List<RepositoryTreeObject>> {
+        private final String mNewPath;
+        public FilesCallback(String newPath) {
+            this.mNewPath = newPath;
+        }
         @Override
-        public void onBreadcrumbClicked() {
-            loadData();
+        public void onResponse(Response<List<RepositoryTreeObject>> response, Retrofit retrofit) {
+            if (getView() == null) {
+                return;
+            }
+
+            mSwipeRefreshLayout.setRefreshing(false);
+
+            if (!response.isSuccess()) {
+                Timber.e("Files response was not a success: %d", response.code());
+                mMessageView.setVisibility(View.VISIBLE);
+                mMessageView.setText(R.string.connection_error_files);
+                mFilesAdapter.setData(null);
+
+                mCurrentPath = mNewPath;
+                updateBreadcrumbs();
+                return;
+            }
+
+            if (!response.body().isEmpty()) {
+                mMessageView.setVisibility(View.GONE);
+            } else {
+                Timber.d("No files found");
+                mMessageView.setVisibility(View.VISIBLE);
+                mMessageView.setText(R.string.no_files_found);
+            }
+
+            mFilesAdapter.setData(response.body());
+            mFilesListView.scrollToPosition(0);
+            mCurrentPath = mNewPath;
+            updateBreadcrumbs();
         }
-    };
-    private FilesAdapter.Listener mFilesAdapterListener = new FilesAdapter.Listener() {
+        @Override
+        public void onFailure(Throwable t) {
+            Timber.e(t, null);
+
+            if (getView() == null) {
+                return;
+            }
+            mSwipeRefreshLayout.setRefreshing(false);
+
+            mMessageView.setVisibility(View.VISIBLE);
+            mMessageView.setText(R.string.connection_error);
+            mFilesAdapter.setData(null);
+
+            mCurrentPath = mNewPath;
+            updateBreadcrumbs();
+        }
+    }
+
+    private final FilesAdapter.Listener mFilesAdapterListener = new FilesAdapter.Listener() {
         @Override
-        public void onFolderClicked(TreeItem treeItem) {
-            mBreadcrumbAdapter.addBreadcrumb(treeItem.getName());
-            mBreadcrumbList.scrollToPosition(mBreadcrumbAdapter.getItemCount() - 1);
-            loadData();
+        public void onFolderClicked(RepositoryTreeObject treeItem) {
+            loadData(mCurrentPath + treeItem.getName() + "/");
         }
         @Override
-        public void onFileClicked(TreeItem treeItem) {
-            String pathExtra = mBreadcrumbAdapter.getCurrentPath();
-            pathExtra = pathExtra + treeItem.getName();
-            NavigationManager.navigateToFile(getActivity(), mProject.getId(), pathExtra, mBranchName);
+        public void onFileClicked(RepositoryTreeObject treeItem) {
+            String path = mCurrentPath + treeItem.getName();
+            NavigationManager.navigateToFile(getActivity(), mProject.getId(), path, mBranchName);
         }
         @Override
-        public void onCopyClicked(TreeItem treeItem) {
-            ClipboardManager clipboard = (ClipboardManager)
-                    getActivity().getSystemService(Context.CLIPBOARD_SERVICE);
+        public void onCopyClicked(RepositoryTreeObject treeItem) {
+            ClipboardManager clipboard = (ClipboardManager) getActivity().getSystemService(Context.CLIPBOARD_SERVICE);
+
             // Creates a new text clip to put on the clipboard
-            ClipData clip = ClipData.newPlainText(treeItem.getName(), treeItem.getUrl(mProject, mBranchName, mBreadcrumbAdapter.getCurrentPath()));
+            ClipData clip = ClipData.newPlainText(treeItem.getName(), treeItem.getUrl(mProject, mBranchName, mCurrentPath).toString());
             clipboard.setPrimaryClip(clip);
             Toast.makeText(getActivity(), R.string.copied_to_clipboard, Toast.LENGTH_SHORT)
                     .show();
         }
         @Override
-        public void onShareClicked(TreeItem treeItem){
-            IntentUtil.share(getView(), treeItem.getUrl(mProject, mBranchName, mBreadcrumbAdapter.getCurrentPath()));
+        public void onShareClicked(RepositoryTreeObject treeItem){
+            IntentUtil.share(getView(), treeItem.getUrl(mProject, mBranchName, mCurrentPath));
         }
         @Override
-        public void onOpenInBrowserClicked(TreeItem treeItem){
-            IntentUtil.openPage(getView(), treeItem.getUrl(mProject, mBranchName, mBreadcrumbAdapter.getCurrentPath()));
+        public void onOpenInBrowserClicked(RepositoryTreeObject treeItem){
+            IntentUtil.openPage(getView(), treeItem.getUrl(mProject, mBranchName, mCurrentPath));
         }
     };
-	private Callback<List<TreeItem>> mFilesCallback = new Callback<List<TreeItem>>() {
-
-		@Override
-		public void onResponse(Response<List<TreeItem>> response, Retrofit retrofit) {
-            if (getView() == null) {
-                return;
-            }
-            mSwipeRefreshLayout.setRefreshing(false);
-			if (!response.isSuccess()) {
-                mBreadcrumbAdapter.clear();
-                mFilesAdapter.clear();
-                mErrorText.setVisibility(View.VISIBLE);
-				return;
-			}
-			if (response.body().isEmpty()) {
-                mFilesAdapter.clear();
-                mErrorText.setVisibility(View.VISIBLE);
-			} else {
-                mFilesList.setVisibility(View.VISIBLE);
-                mFilesAdapter.setData(response.body());
-                mErrorText.setVisibility(View.GONE);
-			}
-		}
-
-		@Override
-		public void onFailure(Throwable t) {
-            Timber.e(t.toString());
-            if (getView() == null) {
-                return;
-            }
-            mSwipeRefreshLayout.setRefreshing(false);
-			Snackbar.make(getActivity().getWindow().getDecorView(), getString(R.string.connection_error_files), Snackbar.LENGTH_SHORT)
-					.show();
-		}
-	};
-
     @Override
-	public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
-		return inflater.inflate(R.layout.fragment_files, container, false);
-	}
+    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+        return inflater.inflate(R.layout.fragment_files, container, false);
+    }
     @Override
     public void onViewCreated(View view, Bundle savedInstanceState) {
         super.onViewCreated(view, savedInstanceState);
         ButterKnife.bind(this, view);
+        mEventReceiver = new EventReceiver();
+        GitLabApp.bus().register(mEventReceiver);
+
         mFilesAdapter = new FilesAdapter(mFilesAdapterListener);
-        mFilesList.setAdapter(mFilesAdapter);
-        mFilesList.setLayoutManager(new LinearLayoutManager(getActivity()));
-        mBreadcrumbAdapter = new BreadcrumbAdapter(mBreadcrumbAdapterListener);
-        mBreadcrumbList.setLayoutManager(new LinearLayoutManager(getActivity(), LinearLayoutManager.HORIZONTAL, false));
-        mBreadcrumbList.setAdapter(mBreadcrumbAdapter);
+        mFilesListView.setLayoutManager(new LinearLayoutManager(getActivity()));
+        mFilesListView.setAdapter(mFilesAdapter);
+
+        mBreadcrumbAdapter = new BreadcrumbAdapter();
+        mBreadcrumbListView.setLayoutManager(new LinearLayoutManager(getActivity(), LinearLayoutManager.HORIZONTAL, false));
+        mBreadcrumbListView.setAdapter(mBreadcrumbAdapter);
         mSwipeRefreshLayout.setOnRefreshListener(new SwipeRefreshLayout.OnRefreshListener() {
             @Override
@@ -162,59 +176,101 @@ public class FilesFragment extends BaseFragment {
             }
         });
-        mEventReceiver = new EventReceiver();
-        GitLabApp.bus().register(mEventReceiver);
-
         if (getActivity() instanceof ProjectActivity) {
             mProject = ((ProjectActivity) getActivity()).getProject();
             mBranchName = ((ProjectActivity) getActivity()).getBranchName();
-            if (!TextUtils.isEmpty(mBranchName) && mProject != null) {
-                loadData();
-            }
+            loadData("");
         } else {
             throw new IllegalStateException("Incorrect parent activity");
         }
     }
     @Override
-	public void onDestroyView() {
-		super.onDestroyView();
-        GitLabApp.bus().unregister(mEventReceiver);
+    public void onDestroyView() {
+        super.onDestroyView();
         ButterKnife.unbind(this);
-	}
-
-	@Override
-	protected void loadData() {
-		mSwipeRefreshLayout.post(new Runnable() {
-			@Override
-			public void run() {
-				if (mSwipeRefreshLayout != null) {
-					mSwipeRefreshLayout.setRefreshing(true);
-				}
-			}
-		});
-
-        GitLabClient.instance().getTree(mProject.getId(), mBranchName, mBreadcrumbAdapter.getCurrentPath()).enqueue(mFilesCallback);
+        GitLabApp.bus().unregister(mEventReceiver);
+    }
+
+    @Override
+    protected void loadData() {
+        loadData(mCurrentPath);
+    }
+
+    public void loadData(String newPath) {
+        if (getView() == null) {
+            return;
+        }
+
+        if (mProject == null || TextUtils.isEmpty(mBranchName)) {
+            mSwipeRefreshLayout.setRefreshing(false);
+            return;
+        }
+
+        mSwipeRefreshLayout.post(new Runnable() {
+            @Override
+            public void run() {
+                if (mSwipeRefreshLayout != null) {
+                    mSwipeRefreshLayout.setRefreshing(true);
+                }
+            }
+        });
+
+        GitLabClient.instance().getTree(mProject.getId(), mBranchName, newPath).enqueue(new FilesCallback(newPath));
+    }
+
+    @Override
+    public boolean onBackPressed() {
+        if (mBreadcrumbAdapter.getItemCount() > 1) {
+            BreadcrumbAdapter.Breadcrumb breadcrumb = mBreadcrumbAdapter.getValueAt(mBreadcrumbAdapter.getItemCount() - 2);
+            if (breadcrumb != null && breadcrumb.getListener() != null) {
+                breadcrumb.getListener().onClick();
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private void updateBreadcrumbs() {
+        List<BreadcrumbAdapter.Breadcrumb> breadcrumbs = new ArrayList<>();
+        breadcrumbs.add(new BreadcrumbAdapter.Breadcrumb(mProject.getName(), new BreadcrumbAdapter.Listener() {
+            @Override
+            public void onClick() {
+                loadData("");
+            }
+        }));
+
+        String newPath = "";
+
+        String[] segments = mCurrentPath.split("/");
+        for (String segment : segments) {
+            if (segment.isEmpty()) {
+                continue;
+            }
+
+            newPath += segment + "/";
+
+            final String finalPath = newPath;
+            breadcrumbs.add(new BreadcrumbAdapter.Breadcrumb(segment, new BreadcrumbAdapter.Listener() {
+                @Override
+                public void onClick() {
+                    loadData(finalPath);
+                }
+            }));
+        }
+
+        mBreadcrumbAdapter.setData(breadcrumbs);
+        mBreadcrumbListView.scrollToPosition(mBreadcrumbAdapter.getItemCount() - 1);
+    }
+
+    private class EventReceiver {
+        @Subscribe
+        public void onProjectReload(ProjectReloadEvent event) {
+            mProject = event.mProject;
+            mBranchName = event.mBranchName;
+
+            loadData("");
+        }
     }
-	
-	public boolean onBackPressed() {
-//		if(mPath.size() > 0) {
-//            mPath.remove(mPath.size() - 1);
-//            loadData();
-//			return true;
-//		}
-//
-		return false;
-	}
-
-	private class EventReceiver {
-
-		@Subscribe
-		public void onLoadReady(ProjectReloadEvent event) {
-            mBreadcrumbAdapter.clear();
-            mProject = event.project;
-            mBranchName = event.branchName;
-			loadData();
-		}
-	}
 }
\ No newline at end of file

app/src/main/java/com/commit451/gitlab/fragment/GroupMembersFragment.java

+package com.commit451.gitlab.fragment;
+
+import com.commit451.gitlab.GitLabApp;
+import com.commit451.gitlab.R;
+import com.commit451.gitlab.adapter.GroupMembersAdapter;
+import com.commit451.gitlab.api.GitLabClient;
+import com.commit451.gitlab.dialog.AccessDialog;
+import com.commit451.gitlab.event.MemberAddedEvent;
+import com.commit451.gitlab.model.api.Group;
+import com.commit451.gitlab.model.api.Member;
+import com.commit451.gitlab.util.NavigationManager;
+import com.commit451.gitlab.viewHolder.ProjectMemberViewHolder;
+import com.squareup.otto.Subscribe;
+
+import org.parceler.Parcels;
+
+import android.os.Bundle;
+import android.support.design.widget.Snackbar;
+import android.support.v4.widget.SwipeRefreshLayout;
+import android.support.v7.widget.GridLayoutManager;
+import android.support.v7.widget.RecyclerView;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.TextView;
+
+import java.util.List;
+
+import butterknife.Bind;
+import butterknife.ButterKnife;
+import butterknife.OnClick;
+import retrofit.Callback;
+import retrofit.Response;
+import retrofit.Retrofit;
+import timber.log.Timber;
+
+public class GroupMembersFragment extends BaseFragment {
+
+    private static final String KEY_GROUP = "group";
+
+    public static GroupMembersFragment newInstance(Group group) {
+        Bundle args = new Bundle();
+        args.putParcelable(KEY_GROUP, Parcels.wrap(group));
+
+        GroupMembersFragment fragment = new GroupMembersFragment();
+        fragment.setArguments(args);
+        return fragment;
+    }
+
+    @Bind(R.id.root) View mRoot;
+    @Bind(R.id.swipe_layout) SwipeRefreshLayout mSwipeRefreshLayout;
+    @Bind(R.id.list) RecyclerView mRecyclerView;
+    @Bind(R.id.message_text) TextView mMessageView;
+    @Bind(R.id.add_user_button) View mAddUserButton;
+
+    private Group mGroup;
+    private EventReceiver mEventReceiver;
+    private GroupMembersAdapter mGroupMembersAdapter;
+    private Member mMember;
+
+    private final Callback<List<Member>> mGroupMembersCallback = new Callback<List<Member>>() {
+        @Override
+        public void onResponse(Response<List<Member>> response, Retrofit retrofit) {
+            if (getView() == null) {
+                return;
+            }
+
+            mSwipeRefreshLayout.setRefreshing(false);
+
+            if (!response.isSuccess()) {
+                Timber.e("Group members response was not a success: %d", response.code());
+                mMessageView.setVisibility(View.VISIBLE);
+                mMessageView.setText(R.string.connection_error_users);
+                mAddUserButton.setVisibility(View.GONE);
+                mGroupMembersAdapter.setData(null);
+                return;
+            }
+
+            if (!response.body().isEmpty()) {
+                mMessageView.setVisibility(View.GONE);
+            } else {
+                Timber.d("No group members found");
+                mMessageView.setVisibility(View.VISIBLE);
+                mMessageView.setText(R.string.no_project_members);
+            }
+
+            mAddUserButton.setVisibility(View.VISIBLE);
+
+            mGroupMembersAdapter.setData(response.body());
+        }
+
+        @Override
+        public void onFailure(Throwable t) {
+            Timber.e(t, null);
+
+            if (getView() == null) {
+                return;
+            }
+
+            mSwipeRefreshLayout.setRefreshing(false);
+
+            mMessageView.setVisibility(View.VISIBLE);
+            mMessageView.setText(R.string.connection_error);
+            mAddUserButton.setVisibility(View.GONE);
+            mGroupMembersAdapter.setData(null);
+        }
+    };
+
+    private final Callback<Void> mRemoveMemberCallback = new Callback<Void>() {
+        @Override
+        public void onResponse(Response<Void> response, Retrofit retrofit) {
+            if (getView() == null) {
+                return;
+            }
+
+            if (!response.isSuccess()) {
+                Timber.e("Remove member response was not a success: %d", response.code());
+                Snackbar.make(mRoot, R.string.failed_to_remove_member, Snackbar.LENGTH_SHORT)
+                        .show();
+                return;
+            }
+
+            mGroupMembersAdapter.removeMember(mMember);
+        }
+
+        @Override
+        public void onFailure(Throwable t) {
+            Timber.e(t, null);
+
+            if (getView() == null) {
+                return;
+            }
+
+            Snackbar.make(mRoot, R.string.connection_error, Snackbar.LENGTH_SHORT)
+                    .show();
+        }
+    };
+
+    private final AccessDialog.OnAccessChangedListener mOnAccessChangedListener = new AccessDialog.OnAccessChangedListener() {
+        @Override
+        public void onAccessChanged(Member member, String accessLevel) {
+            loadData();
+        }
+    };
+
+
+
+    private final GroupMembersAdapter.Listener mListener = new GroupMembersAdapter.Listener() {
+        @Override
+        public void onUserClicked(Member member, ProjectMemberViewHolder holder) {
+            NavigationManager.navigateToUser(getActivity(), holder.mImageView, member);
+        }
+
+        @Override
+        public void onUserRemoveClicked(Member member) {
+            mMember = member;
+            GitLabClient.instance().removeGroupMember(mGroup.getId(), member.getId()).enqueue(mRemoveMemberCallback);
+        }
+
+        @Override
+        public void onUserChangeAccessClicked(Member member) {
+            AccessDialog accessDialog = new AccessDialog(getActivity(), member, mGroup);
+            accessDialog.setOnAccessChangedListener(mOnAccessChangedListener);
+            accessDialog.show();
+        }
+    };
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        mGroup = Parcels.unwrap(getArguments().getParcelable(KEY_GROUP));
+    }
+
+    @Override
+    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+        return inflater.inflate(R.layout.fragment_group_members, container, false);
+    }
+
+    @Override
+    public void onViewCreated(View view, Bundle savedInstanceState) {
+        super.onViewCreated(view, savedInstanceState);
+        ButterKnife.bind(this, view);
+
+        mEventReceiver = new EventReceiver();
+        GitLabApp.bus().register(mEventReceiver);
+
+        mGroupMembersAdapter = new GroupMembersAdapter(mListener);
+        mRecyclerView.setLayoutManager(new GridLayoutManager(getActivity(), 2));
+        mRecyclerView.setAdapter(mGroupMembersAdapter);
+
+        mSwipeRefreshLayout.setOnRefreshListener(new SwipeRefreshLayout.OnRefreshListener() {
+            @Override
+            public void onRefresh() {
+                loadData();
+            }
+        });
+
+        loadData();
+    }
+
+    @Override
+    public void onDestroyView() {
+        super.onDestroyView();
+        ButterKnife.unbind(this);
+        GitLabApp.bus().unregister(mEventReceiver);
+    }
+
+    @OnClick(R.id.add_user_button)
+    public void onAddUserClick() {
+        NavigationManager.navigateToAddGroupMember(getActivity(), mGroup);
+    }
+
+    public void loadData() {
+        if (getView() == null) {
+            return;
+        }
+
+        if (mGroup == null) {
+            mSwipeRefreshLayout.setRefreshing(false);
+            return;
+        }
+
+        mSwipeRefreshLayout.post(new Runnable() {
+            @Override
+            public void run() {
+                if (mSwipeRefreshLayout != null) {
+                    mSwipeRefreshLayout.setRefreshing(true);
+                }
+            }
+        });
+
+        GitLabClient.instance().getGroupMembers(mGroup.getId()).enqueue(mGroupMembersCallback);
+    }
+
+    private class EventReceiver {
+        @Subscribe
+        public void onMemberAdded(MemberAddedEvent event) {
+            if (mGroupMembersAdapter != null) {
+                mGroupMembersAdapter.addMember(event.mMember);
+                mMessageView.setVisibility(View.GONE);
+            }
+        }
+    }
+}
\ No newline at end of file

app/src/main/java/com/commit451/gitlab/fragments/IssuesFragment.java → app/src/main/java/com/commit451/gitlab/fragment/IssuesFragment.java

-package com.commit451.gitlab.fragments;
+package com.commit451.gitlab.fragment;
+import android.net.Uri;
 import android.os.Bundle;
 import android.support.design.widget.Snackbar;
 import android.support.v4.widget.SwipeRefreshLayout;
@@ -15,21 +16,22 @@ import android.widget.TextView;
 import com.commit451.gitlab.GitLabApp;
 import com.commit451.gitlab.R;
-import com.commit451.gitlab.activities.ProjectActivity;
+import com.commit451.gitlab.activity.ProjectActivity;
 import com.commit451.gitlab.adapter.IssuesAdapter;
 import com.commit451.gitlab.api.GitLabClient;
-import com.commit451.gitlab.events.IssueChangedEvent;
-import com.commit451.gitlab.events.IssueCreatedEvent;
-import com.commit451.gitlab.events.ProjectReloadEvent;
-import com.commit451.gitlab.model.Issue;
-import com.commit451.gitlab.model.Project;
-import com.commit451.gitlab.tools.NavigationManager;
+import com.commit451.gitlab.event.IssueChangedEvent;
+import com.commit451.gitlab.event.IssueCreatedEvent;
+import com.commit451.gitlab.event.IssueReloadEvent;
+import com.commit451.gitlab.event.ProjectReloadEvent;
+import com.commit451.gitlab.model.api.Issue;
+import com.commit451.gitlab.model.api.Project;
+import com.commit451.gitlab.util.NavigationManager;
+import com.commit451.gitlab.util.PaginationUtil;
 import com.squareup.otto.Subscribe;
 import java.util.List;
 import butterknife.Bind;
-import butterknife.BindString;
 import butterknife.ButterKnife;
 import butterknife.OnClick;
 import retrofit.Callback;
@@ -39,34 +41,117 @@ import timber.log.Timber;
 public class IssuesFragment extends BaseFragment {
-	public static IssuesFragment newInstance() {
-		return new IssuesFragment();
-	}
-	@Bind(R.id.issue_spinner) Spinner mSpinner;
-	@Bind(R.id.add_issue_button) View mAddIssueButton;
-	@Bind(R.id.list) RecyclerView mIssueRecyclerView;
+    public static IssuesFragment newInstance() {
+        return new IssuesFragment();
+    }
     @Bind(R.id.swipe_layout) SwipeRefreshLayout mSwipeRefreshLayout;
-    @Bind(R.id.message_text) TextView mMessageTextView;
-	IssuesAdapter mIssuesAdapter;
-	EventReceiver mEventReceiver;
-    Project mProject;
-    @BindString(R.string.issue_opened)
+    @Bind(R.id.list) RecyclerView mIssueListView;
+    @Bind(R.id.message_text) TextView mMessageView;
+    @Bind(R.id.issue_spinner) Spinner mSpinner;
+
+    private Project mProject;
+    private IssuesAdapter mIssuesAdapter;
+    private LinearLayoutManager mIssuesLayoutManager;
+    private EventReceiver mEventReceiver;
     String mState;
-    String[] mStates;
-	private final IssuesAdapter.Listener mIssuesAdapterListener = new IssuesAdapter.Listener() {
-		@Override
-		public void onIssueClicked(Issue issue) {
-            NavigationManager.navigateToIssue(getActivity(), mProject, issue);
-		}
-	};
-    private final SwipeRefreshLayout.OnRefreshListener mOnRefreshListener = new SwipeRefreshLayout.OnRefreshListener() {
+    private String[] mStates;
+    private Uri mNextPageUrl;
+    private boolean mLoading = false;
+    private final RecyclerView.OnScrollListener mOnScrollListener = new RecyclerView.OnScrollListener() {
+        @Override
+        public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
+            super.onScrolled(recyclerView, dx, dy);
+            int visibleItemCount = mIssuesLayoutManager.getChildCount();
+            int totalItemCount = mIssuesLayoutManager.getItemCount();
+            int firstVisibleItem = mIssuesLayoutManager.findFirstVisibleItemPosition();
+            if (firstVisibleItem + visibleItemCount >= totalItemCount && !mLoading && mNextPageUrl != null) {
+                loadMore();
+            }
+        }
+    };
+    private final Callback<List<Issue>> mIssuesCallback = new Callback<List<Issue>>() {
         @Override
-        public void onRefresh() {
-            loadData();
+        public void onResponse(Response<List<Issue>> response, Retrofit retrofit) {
+            mLoading = false;
+            if (getView() == null) {
+                return;
+            }
+
+            mSwipeRefreshLayout.setRefreshing(false);
+
+            if (!response.isSuccess()) {
+                Timber.e("Issues response was not a success: %d", response.code());
+                mMessageView.setVisibility(View.VISIBLE);
+                mMessageView.setText(R.string.connection_error_issues);
+                mIssuesAdapter.setIssues(null);
+                mNextPageUrl = null;
+                return;
+            }
+
+            if (!response.body().isEmpty()) {
+                mMessageView.setVisibility(View.GONE);
+            } else if (mNextPageUrl == null) {
+                Timber.d("No issues found");
+                mMessageView.setVisibility(View.VISIBLE);
+                mMessageView.setText(R.string.no_issues);
+            }
+
+            mIssuesAdapter.setIssues(response.body());
+            mNextPageUrl = PaginationUtil.parse(response).getNext();
+            Timber.d("Next page url " + mNextPageUrl);
+        }
+
+        @Override
+        public void onFailure(Throwable t) {
+            mLoading = false;
+            Timber.e(t, null);
+
+            if (getView() == null) {
+                return;
+            }
+
+            mSwipeRefreshLayout.setRefreshing(false);
+
+            mMessageView.setVisibility(View.VISIBLE);
+            mMessageView.setText(R.string.connection_error);
+            mIssuesAdapter.setIssues(null);
+            mNextPageUrl = null;
+        }
+    };
+
+    private final Callback<List<Issue>> mMoreIssuesCallback = new Callback<List<Issue>>() {
+        @Override
+        public void onResponse(Response<List<Issue>> response, Retrofit retrofit) {
+            if (!response.isSuccess()) {
+                return;
+            }
+            mLoading = false;
+            mIssuesAdapter.setLoading(false);
+            mNextPageUrl = PaginationUtil.parse(response).getNext();
+            mIssuesAdapter.addIssues(response.body());
+        }
+
+        @Override
+        public void onFailure(Throwable t) {
+            Timber.e(t, null);
+            mIssuesAdapter.setLoading(false);
+            mLoading = false;
+        }
+    };
+
+    private final IssuesAdapter.Listener mIssuesAdapterListener = new IssuesAdapter.Listener() {
+        @Override
+        public void onIssueClicked(Issue issue) {
+            if (mProject != null) {
+                NavigationManager.navigateToIssue(getActivity(), mProject, issue);
+            } else {
+                Snackbar.make(getActivity().getWindow().getDecorView(), getString(R.string.wait_for_project_to_load), Snackbar.LENGTH_SHORT)
+                        .show();
+            }
         }
     };
@@ -78,132 +163,136 @@ public class IssuesFragment extends BaseFragment {
         }
         @Override
-        public void onNothingSelected(AdapterView<?> parent) { }
+        public void onNothingSelected(AdapterView<?> parent) {}
     };
-	public IssuesFragment() {}
-
     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
+        mState = getResources().getString(R.string.issue_state_value_default);
         mStates = getResources().getStringArray(R.array.issue_state_values);
     }
     @Override
-	public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
-		return inflater.inflate(R.layout.fragment_issues, container, false);
-	}
+    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+        return inflater.inflate(R.layout.fragment_issues, container, false);
+    }
     @Override
     public void onViewCreated(View view, Bundle savedInstanceState) {
         super.onViewCreated(view, savedInstanceState);
         ButterKnife.bind(this, view);
-        mIssueRecyclerView.setLayoutManager(new LinearLayoutManager(getActivity()));
+        mEventReceiver = new EventReceiver();
+        GitLabApp.bus().register(mEventReceiver);
+
         mIssuesAdapter = new IssuesAdapter(mIssuesAdapterListener);
-        mIssueRecyclerView.setAdapter(mIssuesAdapter);
-        mSwipeRefreshLayout.setOnRefreshListener(mOnRefreshListener);
+        mIssuesLayoutManager = new LinearLayoutManager(getActivity());
+        mIssueListView.setLayoutManager(mIssuesLayoutManager);
+        mIssueListView.setAdapter(mIssuesAdapter);
+        mIssueListView.addOnScrollListener(mOnScrollListener);
+
         mSpinner.setAdapter(new ArrayAdapter<>(getActivity(), android.R.layout.simple_list_item_1, android.R.id.text1, getResources().getStringArray(R.array.issue_state_names)));
         mSpinner.setOnItemSelectedListener(mSpinnerItemSelectedListener);
-        mEventReceiver = new EventReceiver();
-        GitLabApp.bus().register(mEventReceiver);
+        mSwipeRefreshLayout.setOnRefreshListener(new SwipeRefreshLayout.OnRefreshListener() {
+            @Override
+            public void onRefresh() {
+                loadData();
+            }
+        });
         if (getActivity() instanceof ProjectActivity) {
             mProject = ((ProjectActivity) getActivity()).getProject();
-            if (mProject != null) {
-                loadData();
-            }
+            loadData();
         } else {
             throw new IllegalStateException("Incorrect parent activity");
         }
     }
     @Override
-	public void onDestroyView() {
-		super.onDestroyView();
+    public void onDestroyView() {
+        super.onDestroyView();
         ButterKnife.unbind(this);
-		GitLabApp.bus().unregister(mEventReceiver);
+        GitLabApp.bus().unregister(mEventReceiver);
     }
-	
-	public void loadData() {
-        mMessageTextView.setVisibility(View.GONE);
-		mSwipeRefreshLayout.post(new Runnable() {
-			@Override
-			public void run() {
-				if (mSwipeRefreshLayout != null) {
-					mSwipeRefreshLayout.setRefreshing(true);
-				}
-			}
-		});
-		GitLabClient.instance().getIssues(mProject.getId(), mState).enqueue(mIssuesCallback);
-	}
-	
-	private Callback<List<Issue>> mIssuesCallback = new Callback<List<Issue>>() {
-
-		@Override
-		public void onResponse(Response<List<Issue>> response, Retrofit retrofit) {
-			if (getView() == null) {
-                return;
-            }
-            if (!response.isSuccess()) {
-                return;
-            }
-            mSwipeRefreshLayout.setRefreshing(false);
-			if (response.body().isEmpty()) {
-                mMessageTextView.setVisibility(View.VISIBLE);
-            }
-
-            mIssuesAdapter.setIssues(response.body());
-		}
-
-		@Override
-		public void onFailure(Throwable t) {
-			Timber.e(t.toString());
-            if (getView() == null) {
-                return;
-            }
-			if(mSwipeRefreshLayout != null && mSwipeRefreshLayout.isRefreshing()) {
-				mSwipeRefreshLayout.setRefreshing(false);
-			}
-			Snackbar.make(getActivity().getWindow().getDecorView(), getString(R.string.connection_error_issues), Snackbar.LENGTH_SHORT)
-					.show();
-			mIssueRecyclerView.setAdapter(null);
-		}
-	};
-	
-	public boolean onBackPressed() {
-		return false;
-	}
-
-	@OnClick(R.id.add_issue_button)
-	public void onAddIssueClick(View fab) {
+    @OnClick(R.id.add_issue_button)
+    public void onAddIssueClick(View fab) {
         if (mProject != null) {
             NavigationManager.navigateToAddIssue(getActivity(), fab, mProject);
         } else {
             Snackbar.make(getActivity().getWindow().getDecorView(), getString(R.string.wait_for_project_to_load), Snackbar.LENGTH_SHORT)
                     .show();
         }
-	}
-	private class EventReceiver {
+    }
+
+    @Override
+    protected void loadData() {
+        if (getView() == null) {
+            return;
+        }
+
+        if (mProject == null) {
+            mSwipeRefreshLayout.setRefreshing(false);
+            return;
+        }
+
+        mSwipeRefreshLayout.post(new Runnable() {
+            @Override
+            public void run() {
+                if (mSwipeRefreshLayout != null) {
+                    mSwipeRefreshLayout.setRefreshing(true);
+                }
+            }
+        });
+
+        mNextPageUrl = null;
+        mLoading = true;
+
+        GitLabClient.instance().getIssues(mProject.getId(), mState).enqueue(mIssuesCallback);
+    }
+
+    private void loadMore() {
+        if (getView() == null) {
+            return;
+        }
+
+        if (mNextPageUrl == null) {
+            return;
+        }
+        mIssuesAdapter.setLoading(true);
+        mLoading = true;
+        Timber.d("loadMore called for " + mNextPageUrl);
+        GitLabClient.instance().getIssues(mNextPageUrl.toString(), mState).enqueue(mMoreIssuesCallback);
+    }
+
+    private class EventReceiver {
         @Subscribe
-        public void onReloadData(ProjectReloadEvent event) {
-            mProject = event.project;
+        public void onProjectReload(ProjectReloadEvent event) {
+            mProject = event.mProject;
             loadData();
         }
-		@Subscribe
-		public void onIssueAdded(IssueCreatedEvent event) {
-			mIssuesAdapter.addIssue(event.issue);
-            mIssueRecyclerView.smoothScrollToPosition(0);
-		}
-		@Subscribe
-		public void onIssueChanged(IssueChangedEvent event) {
-			mIssuesAdapter.updateIssue(event.issue);
-		}
-	}
+        @Subscribe
+        public void onIssueCreated(IssueCreatedEvent event) {
+            mIssuesAdapter.addIssue(event.mIssue);
+            if (getView() != null) {
+                mMessageView.setVisibility(View.GONE);
+                mIssueListView.smoothScrollToPosition(0);
+            }
+        }
+
+        @Subscribe
+        public void onIssueChanged(IssueChangedEvent event) {
+            mIssuesAdapter.updateIssue(event.mIssue);
+        }
+        @Subscribe
+        public void onIssueReload(IssueReloadEvent event) {
+            loadData();
+        }
+    }
 }
\ No newline at end of file

app/src/main/java/com/commit451/gitlab/fragments/MergeRequestsFragment.java → app/src/main/java/com/commit451/gitlab/fragment/MergeRequestsFragment.java

-package com.commit451.gitlab.fragments;
+package com.commit451.gitlab.fragment;
+import android.net.Uri;
 import android.os.Bundle;
-import android.support.annotation.Nullable;
-import android.support.design.widget.Snackbar;
 import android.support.v4.widget.SwipeRefreshLayout;
 import android.support.v7.widget.LinearLayoutManager;
 import android.support.v7.widget.RecyclerView;
@@ -16,55 +15,45 @@ import android.widget.TextView;
 import com.commit451.gitlab.GitLabApp;
 import com.commit451.gitlab.R;
-import com.commit451.gitlab.activities.ProjectActivity;
+import com.commit451.gitlab.activity.ProjectActivity;
 import com.commit451.gitlab.adapter.MergeRequestAdapter;
 import com.commit451.gitlab.api.GitLabClient;
-import com.commit451.gitlab.events.ProjectReloadEvent;
-import com.commit451.gitlab.model.MergeRequest;
-import com.commit451.gitlab.model.Project;
-import com.commit451.gitlab.tools.NavigationManager;
+import com.commit451.gitlab.event.ProjectReloadEvent;
+import com.commit451.gitlab.model.api.MergeRequest;
+import com.commit451.gitlab.model.api.Project;
+import com.commit451.gitlab.util.NavigationManager;
+import com.commit451.gitlab.util.PaginationUtil;
 import com.squareup.otto.Subscribe;
 import java.util.List;
 import butterknife.Bind;
-import butterknife.BindString;
 import butterknife.ButterKnife;
 import retrofit.Callback;
 import retrofit.Response;
 import retrofit.Retrofit;
-/**
- * Merge all the requests!
- * Created by Jawn on 9/20/2015.
- */
+import timber.log.Timber;
 public class MergeRequestsFragment extends BaseFragment {
     public static MergeRequestsFragment newInstance() {
-        Bundle args = new Bundle();
-        MergeRequestsFragment fragment = new MergeRequestsFragment();
-        fragment.setArguments(args);
-        return fragment;
+        return new MergeRequestsFragment();
     }
-    @Bind(R.id.error_text) TextView mErrorText;
-    @Bind(R.id.state_spinner) Spinner mSpinner;
     @Bind(R.id.swipe_layout) SwipeRefreshLayout mSwipeRefreshLayout;
     @Bind(R.id.list) RecyclerView mRecyclerView;
-    EventReceiver mEventReceiver;
-    MergeRequestAdapter mMergeRequestAdapter;
-    Project mProject;
-    @BindString(R.string.merge_request_state_value_default)
-    String mState;
-    String[] mStates;
-    private final SwipeRefreshLayout.OnRefreshListener mOnRefreshListener = new SwipeRefreshLayout.OnRefreshListener() {
-        @Override
-        public void onRefresh() {
-            loadData();
-        }
-    };
+    @Bind(R.id.message_text) TextView mMessageView;
+    @Bind(R.id.state_spinner) Spinner mSpinner;
+    private Project mProject;
+    private EventReceiver mEventReceiver;
+    private MergeRequestAdapter mMergeRequestAdapter;
+    private LinearLayoutManager mMergeLayoutManager;
+    private String mState;
+    private String[] mStates;
+    private Uri mNextPageUrl;
+    private boolean mLoading = false;
     private final AdapterView.OnItemSelectedListener mSpinnerItemSelectedListener = new AdapterView.OnItemSelectedListener() {
         @Override
@@ -74,7 +63,7 @@ public class MergeRequestsFragment extends BaseFragment {
         }
         @Override
-        public void onNothingSelected(AdapterView<?> parent) { }
+        public void onNothingSelected(AdapterView<?> parent) {}
     };
     private final MergeRequestAdapter.Listener mMergeRequestAdapterListener = new MergeRequestAdapter.Listener() {
@@ -84,40 +73,96 @@ public class MergeRequestsFragment extends BaseFragment {
         }
     };
+    private final RecyclerView.OnScrollListener mOnScrollListener = new RecyclerView.OnScrollListener() {
+        @Override
+        public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
+            super.onScrolled(recyclerView, dx, dy);
+            int visibleItemCount = mMergeLayoutManager.getChildCount();
+            int totalItemCount = mMergeLayoutManager.getItemCount();
+            int firstVisibleItem = mMergeLayoutManager.findFirstVisibleItemPosition();
+            if (firstVisibleItem + visibleItemCount >= totalItemCount && !mLoading && mNextPageUrl != null) {
+                loadMore();
+            }
+        }
+    };
+
     private final Callback<List<MergeRequest>> mCallback = new Callback<List<MergeRequest>>() {
         @Override
         public void onResponse(Response<List<MergeRequest>> response, Retrofit retrofit) {
-            if (!response.isSuccess()) {
+            mLoading = false;
+            if (getView() == null) {
                 return;
             }
-            if (getView() == null) {
+
+            if (!response.isSuccess()) {
+                Timber.e("Merge requests response was not a success: %d", response.code());
+                mMessageView.setVisibility(View.VISIBLE);
+                mMessageView.setText(R.string.connection_error_merge_requests);
+                mMergeRequestAdapter.setData(null);
+                mNextPageUrl = null;
                 return;
             }
+
             mSwipeRefreshLayout.setRefreshing(false);
-            if (response.body().isEmpty()) {
-                mErrorText.setVisibility(View.VISIBLE);
-                mErrorText.setText(R.string.no_merge_requests);
+
+            if (!response.body().isEmpty()) {
+                mMessageView.setVisibility(View.GONE);
+            } else if (mNextPageUrl == null) {
+                Timber.d("No merge requests found");
+                mMessageView.setVisibility(View.VISIBLE);
+                mMessageView.setText(R.string.no_merge_requests);
             }
             mMergeRequestAdapter.setData(response.body());
+
+            mNextPageUrl = PaginationUtil.parse(response).getNext();
+            Timber.d("Next page url " + mNextPageUrl);
         }
         @Override
         public void onFailure(Throwable t) {
-            if (getView() != null) {
-                mSwipeRefreshLayout.setRefreshing(false);
-                Snackbar.make(getView(), R.string.connection_error, Snackbar.LENGTH_SHORT).show();
+            mLoading = false;
+            Timber.e(t, null);
+
+            if (getView() == null) {
+                return;
             }
+
+            mSwipeRefreshLayout.setRefreshing(false);
+
+            mMessageView.setVisibility(View.VISIBLE);
+            mMessageView.setText(R.string.connection_error);
+            mMergeRequestAdapter.setData(null);
+            mNextPageUrl = null;
+        }
+    };
+
+    private final Callback<List<MergeRequest>> mMoreIssuesCallback = new Callback<List<MergeRequest>>() {
+        @Override
+        public void onResponse(Response<List<MergeRequest>> response, Retrofit retrofit) {
+            if (!response.isSuccess()) {
+                return;
+            }
+            mLoading = false;
+            mMergeRequestAdapter.setLoading(false);
+            mNextPageUrl = PaginationUtil.parse(response).getNext();
+            mMergeRequestAdapter.addData(response.body());
+        }
+
+        @Override
+        public void onFailure(Throwable t) {
+            Timber.e(t, null);
+            mMergeRequestAdapter.setLoading(false);
+            mLoading = false;
         }
     };
     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
-        mEventReceiver = new EventReceiver();
+        mState = getContext().getResources().getString(R.string.merge_request_state_value_default);
         mStates = getContext().getResources().getStringArray(R.array.merge_request_state_values);
     }
-    @Nullable
     @Override
     public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
         return inflater.inflate(R.layout.fragment_merge_request, container, false);
@@ -127,19 +172,29 @@ public class MergeRequestsFragment extends BaseFragment {
     public void onViewCreated(View view, Bundle savedInstanceState) {
         super.onViewCreated(view, savedInstanceState);
         ButterKnife.bind(this, view);
+
+        mEventReceiver = new EventReceiver();
         GitLabApp.bus().register(mEventReceiver);
-        mSwipeRefreshLayout.setOnRefreshListener(mOnRefreshListener);
+
         mMergeRequestAdapter = new MergeRequestAdapter(mMergeRequestAdapterListener);
-        mRecyclerView.setLayoutManager(new LinearLayoutManager(getActivity()));
+        mMergeLayoutManager = new LinearLayoutManager(getActivity());
+        mRecyclerView.setLayoutManager(mMergeLayoutManager);
         mRecyclerView.setAdapter(mMergeRequestAdapter);
+        mRecyclerView.addOnScrollListener(mOnScrollListener);
+
         mSpinner.setAdapter(new ArrayAdapter<>(getActivity(), android.R.layout.simple_list_item_1, android.R.id.text1, getResources().getStringArray(R.array.merge_request_state_names)));
         mSpinner.setOnItemSelectedListener(mSpinnerItemSelectedListener);
-        if (getActivity() instanceof ProjectActivity) {
-            mProject = ((ProjectActivity) getActivity()).getProject();
-            if (mProject != null) {
+        mSwipeRefreshLayout.setOnRefreshListener(new SwipeRefreshLayout.OnRefreshListener() {
+            @Override
+            public void onRefresh() {
                 loadData();
             }
+        });
+
+        if (getActivity() instanceof ProjectActivity) {
+            mProject = ((ProjectActivity) getActivity()).getProject();
+            loadData();
         } else {
             throw new IllegalStateException("Incorrect parent activity");
         }
@@ -148,14 +203,21 @@ public class MergeRequestsFragment extends BaseFragment {
     @Override
     public void onDestroyView() {
         super.onDestroyView();
-        GitLabApp.bus().unregister(mEventReceiver);
         ButterKnife.unbind(this);
+        GitLabApp.bus().unregister(mEventReceiver);
     }
     @Override
     protected void loadData() {
-        super.loadData();
-        mErrorText.setVisibility(View.GONE);
+        if (getView() == null) {
+            return;
+        }
+
+        if (mProject == null) {
+            mSwipeRefreshLayout.setRefreshing(false);
+            return;
+        }
+
         mSwipeRefreshLayout.post(new Runnable() {
             @Override
             public void run() {
@@ -164,18 +226,33 @@ public class MergeRequestsFragment extends BaseFragment {
                 }
             }
         });
+
+        mNextPageUrl = null;
+        mLoading = true;
+
         GitLabClient.instance().getMergeRequests(mProject.getId(), mState).enqueue(mCallback);
     }
-    public boolean onBackPressed() {
-        return false;
+    private void loadMore() {
+        if (getView() == null) {
+            return;
+        }
+
+        if (mNextPageUrl == null) {
+            return;
+        }
+
+        mMergeRequestAdapter.setLoading(true);
+        mLoading = true;
+
+        Timber.d("loadMore called for " + mNextPageUrl);
+        GitLabClient.instance().getMergeRequests(mNextPageUrl.toString(), mState).enqueue(mMoreIssuesCallback);
     }
     private class EventReceiver {
-
         @Subscribe
-        public void onProjectChanged(ProjectReloadEvent event) {
-            mProject = event.project;
+        public void onProjectReload(ProjectReloadEvent event) {
+            mProject = event.mProject;
             loadData();
         }
     }

app/src/main/java/com/commit451/gitlab/model/Avatar.java

-package com.commit451.gitlab.model;
-
-import com.google.gson.annotations.SerializedName;
-
-import org.parceler.Parcel;
-
-/**
- * Avatar. Only used in Namespace for some reason
- * Created by Jawn on 9/22/2015.
- */
-@Parcel
-public class Avatar {
-    @SerializedName("url")
-    String url;
-
-    public Avatar() {}
-}

app/src/main/java/com/commit451/gitlab/model/Branch.java

-package com.commit451.gitlab.model;
-
-import org.parceler.Parcel;
-
-@Parcel
-public class Branch {
-	String name;
-	boolean protected_;
-
-	public Branch(){}
-	
-	public String getName() {
-		return name;
-	}
-	public void setName(String name) {
-		this.name = name;
-	}
-	
-	public boolean isProtected() {
-		return protected_;
-	}
-	public void setProtected(boolean protected_) {
-		this.protected_ = protected_;
-	}
-	
-	public String toString() {
-		return name;
-	}
-}

app/src/main/java/com/commit451/gitlab/model/Contributor.java

-package com.commit451.gitlab.model;
-
-import com.google.gson.annotations.SerializedName;
-
-import org.parceler.Parcel;
-
-/**
- * Contributor to a repo
- * Created by Jawn on 9/20/2015.
- */
-@Parcel
-public class Contributor {
-    @SerializedName("name")
-    String mName;
-    @SerializedName("email")
-    String mEmail;
-    @SerializedName("commits")
-    Integer mCommits;
-    @SerializedName("additions")
-    Integer mAdditions;
-    @SerializedName("deletions")
-    String mDeletions;
-
-    public Contributor() {}
-
-    public String getName() {
-        return mName;
-    }
-
-    public String getEmail() {
-        return mEmail;
-    }
-
-    public Integer getCommits() {
-        return mCommits;
-    }
-
-    public Integer getAdditions() {
-        return mAdditions;
-    }
-
-    public String getDeletions() {
-        return mDeletions;
-    }
-}