Show MultiReddits list.

18 files changed, 1195 insertions, 11 deletions

diff --git a/app/src/main/java/ml/docilealligator/infinityforreddit/Activity/MainActivity.java b/app/src/main/java/ml/docilealligator/infinityforreddit/Activity/MainActivity.java
index 136f697c..11e1480f 100644
--- a/app/src/main/java/ml/docilealligator/infinityforreddit/Activity/MainActivity.java
+++ b/app/src/main/java/ml/docilealligator/infinityforreddit/Activity/MainActivity.java
@@ -808,8 +808,10 @@ public class MainActivity extends BaseActivity implements SortTypeSelectionCallb
     public boolean onOptionsItemSelected(@NonNull MenuItem item) {
         switch (item.getItemId()) {
             case R.id.action_subscriptions_main_activity:
-                Intent subscriptionsIntent = new Intent(this, SubscribedThingListingActivity.class);
-                startActivity(subscriptionsIntent);
+                /*Intent subscriptionsIntent = new Intent(this, SubscribedThingListingActivity.class);
+                startActivity(subscriptionsIntent);*/
+                Intent multiIntent = new Intent(this, MultiRedditListingActivity.class);
+                startActivity(multiIntent);
                 return true;
             case R.id.action_sort_main_activity:
                 if (viewPager.getCurrentItem() == 1 || viewPager.getCurrentItem() == 2) {
diff --git a/app/src/main/java/ml/docilealligator/infinityforreddit/Activity/MultiRedditListingActivity.java b/app/src/main/java/ml/docilealligator/infinityforreddit/Activity/MultiRedditListingActivity.java
new file mode 100644
index 00000000..63aaffdb
--- /dev/null
+++ b/app/src/main/java/ml/docilealligator/infinityforreddit/Activity/MultiRedditListingActivity.java
@@ -0,0 +1,241 @@
+package ml.docilealligator.infinityforreddit.Activity;
+
+import android.content.SharedPreferences;
+import android.content.res.Configuration;
+import android.content.res.Resources;
+import android.os.Build;
+import android.os.Bundle;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.Window;
+import android.view.WindowManager;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+import androidx.annotation.NonNull;
+import androidx.appcompat.widget.Toolbar;
+import androidx.lifecycle.ViewModelProvider;
+import androidx.recyclerview.widget.LinearLayoutManager;
+import androidx.recyclerview.widget.RecyclerView;
+
+import com.bumptech.glide.Glide;
+import com.bumptech.glide.RequestManager;
+import com.google.android.material.appbar.AppBarLayout;
+
+import java.util.ArrayList;
+
+import javax.inject.Inject;
+import javax.inject.Named;
+
+import butterknife.BindView;
+import butterknife.ButterKnife;
+import ml.docilealligator.infinityforreddit.Adapter.MultiRedditListingRecyclerViewAdapter;
+import ml.docilealligator.infinityforreddit.AppBarStateChangeListener;
+import ml.docilealligator.infinityforreddit.AsyncTask.GetCurrentAccountAsyncTask;
+import ml.docilealligator.infinityforreddit.AsyncTask.InsertMultiRedditAsyncTask;
+import ml.docilealligator.infinityforreddit.Infinity;
+import ml.docilealligator.infinityforreddit.MultiReddit.GetMultiReddit;
+import ml.docilealligator.infinityforreddit.MultiReddit.MultiReddit;
+import ml.docilealligator.infinityforreddit.MultiReddit.MultiRedditViewModel;
+import ml.docilealligator.infinityforreddit.R;
+import ml.docilealligator.infinityforreddit.RedditDataRoomDatabase;
+import ml.docilealligator.infinityforreddit.Utils.SharedPreferencesUtils;
+import retrofit2.Retrofit;
+
+public class MultiRedditListingActivity extends BaseActivity {
+
+    private static final String INSERT_MULTI_REDDIT_STATE = "ISSS";
+    private static final String NULL_ACCESS_TOKEN_STATE = "NATS";
+    private static final String ACCESS_TOKEN_STATE = "ATS";
+    private static final String ACCOUNT_NAME_STATE = "ANS";
+
+    @BindView(R.id.appbar_layout_multi_reddit_listing_activity)
+    AppBarLayout mAppBarLayout;
+    @BindView(R.id.toolbar_multi_reddit_listing_activity)
+    Toolbar mToolbar;
+    @BindView(R.id.recycler_view_multi_reddit_listing_activity)
+    RecyclerView mRecyclerView;
+    @BindView(R.id.fetch_multi_reddit_listing_info_linear_layout_multi_reddit_listing_activity)
+    LinearLayout mErrorLinearLayout;
+    @BindView(R.id.fetch_multi_reddit_listing_info_image_view_multi_reddit_listing_activity)
+    ImageView mErrorImageView;
+    @BindView(R.id.fetch_multi_reddit_listing_info_text_view_multi_reddit_listing_activity)
+    TextView mErrorTextView;
+    @Inject
+    RedditDataRoomDatabase mRedditDataRoomDatabase;
+    @Inject
+    SharedPreferences mSharedPreferences;
+    @Inject
+    @Named("oauth")
+    Retrofit mOauthRetrofit;
+
+    MultiRedditViewModel mMultiRedditViewModel;
+    private RequestManager mGlide;
+
+    private boolean mNullAccessToken = false;
+    private String mAccessToken;
+    private String mAccountName;
+    private boolean mInsertSuccess = false;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        ((Infinity) getApplication()).getAppComponent().inject(this);
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_multi_reddit_listing);
+
+        ButterKnife.bind(this);
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1) {
+            Resources resources = getResources();
+
+            if ((resources.getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT || resources.getBoolean(R.bool.isTablet))
+                    && mSharedPreferences.getBoolean(SharedPreferencesUtils.IMMERSIVE_INTERFACE_KEY, true)) {
+                Window window = getWindow();
+                window.setFlags(WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS, WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS);
+
+                boolean lightNavBar = false;
+                if ((resources.getConfiguration().uiMode & Configuration.UI_MODE_NIGHT_MASK) != Configuration.UI_MODE_NIGHT_YES) {
+                    lightNavBar = true;
+                }
+                boolean finalLightNavBar = lightNavBar;
+
+                View decorView = window.getDecorView();
+                if (finalLightNavBar) {
+                    decorView.setSystemUiVisibility(View.SYSTEM_UI_FLAG_LIGHT_NAVIGATION_BAR);
+                }
+                mAppBarLayout.addOnOffsetChangedListener(new AppBarStateChangeListener() {
+                    @Override
+                    public void onStateChanged(AppBarLayout appBarLayout, AppBarStateChangeListener.State state) {
+                        if (state == State.COLLAPSED) {
+                            if (finalLightNavBar) {
+                                decorView.setSystemUiVisibility(View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR | View.SYSTEM_UI_FLAG_LIGHT_NAVIGATION_BAR);
+                            }
+                        } else if (state == State.EXPANDED) {
+                            if (finalLightNavBar) {
+                                decorView.setSystemUiVisibility(View.SYSTEM_UI_FLAG_LIGHT_NAVIGATION_BAR);
+                            }
+                        }
+                    }
+                });
+
+                int statusBarResourceId = getResources().getIdentifier("status_bar_height", "dimen", "android");
+                if (statusBarResourceId > 0) {
+                    ViewGroup.MarginLayoutParams params = (ViewGroup.MarginLayoutParams) mToolbar.getLayoutParams();
+                    params.topMargin = getResources().getDimensionPixelSize(statusBarResourceId);
+                    mToolbar.setLayoutParams(params);
+                }
+
+                int navBarResourceId = resources.getIdentifier("navigation_bar_height", "dimen", "android");
+                if (navBarResourceId > 0) {
+                    mRecyclerView.setPadding(0, 0, 0, resources.getDimensionPixelSize(navBarResourceId));
+                }
+            }
+        }
+
+        setSupportActionBar(mToolbar);
+        getSupportActionBar().setDisplayHomeAsUpEnabled(true);
+
+        if (savedInstanceState != null) {
+            mInsertSuccess = savedInstanceState.getBoolean(INSERT_MULTI_REDDIT_STATE);
+            mNullAccessToken = savedInstanceState.getBoolean(NULL_ACCESS_TOKEN_STATE);
+            mAccessToken = savedInstanceState.getString(ACCESS_TOKEN_STATE);
+            mAccountName = savedInstanceState.getString(ACCOUNT_NAME_STATE);
+            if (!mNullAccessToken && mAccessToken == null) {
+                getCurrentAccountAndBindView();
+            } else {
+                bindView();
+            }
+        } else {
+            getCurrentAccountAndBindView();
+        }
+    }
+
+    private void getCurrentAccountAndBindView() {
+        new GetCurrentAccountAsyncTask(mRedditDataRoomDatabase.accountDao(), account -> {
+            if (account == null) {
+                mNullAccessToken = true;
+            } else {
+                mAccessToken = account.getAccessToken();
+                mAccountName = account.getUsername();
+            }
+            bindView();
+        }).execute();
+    }
+
+    private void bindView() {
+        loadMultiReddits();
+
+        mGlide = Glide.with(this);
+
+        mRecyclerView.setLayoutManager(new LinearLayoutManager(this));
+        MultiRedditListingRecyclerViewAdapter adapter = new MultiRedditListingRecyclerViewAdapter(this,
+                mOauthRetrofit, mRedditDataRoomDatabase, mAccessToken);
+        mRecyclerView.setAdapter(adapter);
+
+        mMultiRedditViewModel = new ViewModelProvider(this,
+                new MultiRedditViewModel.Factory(getApplication(), mRedditDataRoomDatabase, mAccountName))
+                .get(MultiRedditViewModel.class);
+
+        mMultiRedditViewModel.getAllMultiReddits().observe(this, subscribedUserData -> {
+            if (subscribedUserData == null || subscribedUserData.size() == 0) {
+                mRecyclerView.setVisibility(View.GONE);
+                mErrorLinearLayout.setVisibility(View.VISIBLE);
+                mGlide.load(R.drawable.error_image).into(mErrorImageView);
+            } else {
+                mErrorLinearLayout.setVisibility(View.GONE);
+                mRecyclerView.setVisibility(View.VISIBLE);
+                mGlide.clear(mErrorImageView);
+            }
+            adapter.setMultiReddits(subscribedUserData);
+        });
+
+        mMultiRedditViewModel.getAllFavoriteMultiReddits().observe(this, favoriteSubscribedUserData -> {
+            if (favoriteSubscribedUserData != null && favoriteSubscribedUserData.size() > 0) {
+                mErrorLinearLayout.setVisibility(View.GONE);
+                mRecyclerView.setVisibility(View.VISIBLE);
+                mGlide.clear(mErrorImageView);
+            }
+            adapter.setFavoriteMultiReddits(favoriteSubscribedUserData);
+        });
+    }
+
+    private void loadMultiReddits() {
+        GetMultiReddit.getMyMultiReddits(mOauthRetrofit, mAccessToken, new GetMultiReddit.GetMultiRedditListener() {
+            @Override
+            public void success(ArrayList<MultiReddit> multiReddits) {
+                new InsertMultiRedditAsyncTask(mRedditDataRoomDatabase, multiReddits, () -> mInsertSuccess = true).execute();
+            }
+
+            @Override
+            public void failed() {
+                mInsertSuccess = false;
+            }
+        });
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(@NonNull MenuItem item) {
+        if (item.getItemId() == android.R.id.home) {
+            finish();
+            return true;
+        }
+
+        return false;
+    }
+
+    @Override
+    protected void onSaveInstanceState(@NonNull Bundle outState) {
+        super.onSaveInstanceState(outState);
+        outState.putBoolean(INSERT_MULTI_REDDIT_STATE, mInsertSuccess);
+        outState.putBoolean(NULL_ACCESS_TOKEN_STATE, mNullAccessToken);
+        outState.putString(ACCESS_TOKEN_STATE, mAccessToken);
+        outState.putString(ACCOUNT_NAME_STATE, mAccountName);
+    }
+
+    @Override
+    public SharedPreferences getSharedPreferences() {
+        return mSharedPreferences;
+    }
+}
diff --git a/app/src/main/java/ml/docilealligator/infinityforreddit/Adapter/MultiRedditListingRecyclerViewAdapter.java b/app/src/main/java/ml/docilealligator/infinityforreddit/Adapter/MultiRedditListingRecyclerViewAdapter.java
new file mode 100644
index 00000000..7503cfa7
--- /dev/null
+++ b/app/src/main/java/ml/docilealligator/infinityforreddit/Adapter/MultiRedditListingRecyclerViewAdapter.java
@@ -0,0 +1,349 @@
+package ml.docilealligator.infinityforreddit.Adapter;
+
+import android.content.Context;
+import android.content.Intent;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ImageView;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import androidx.annotation.NonNull;
+import androidx.recyclerview.widget.RecyclerView;
+
+import com.bumptech.glide.Glide;
+import com.bumptech.glide.RequestManager;
+import com.bumptech.glide.request.RequestOptions;
+
+import java.util.List;
+
+import butterknife.BindView;
+import butterknife.ButterKnife;
+import jp.wasabeef.glide.transformations.RoundedCornersTransformation;
+import ml.docilealligator.infinityforreddit.Activity.ViewSubredditDetailActivity;
+import ml.docilealligator.infinityforreddit.MultiReddit.FavoriteMultiReddit;
+import ml.docilealligator.infinityforreddit.MultiReddit.MultiReddit;
+import ml.docilealligator.infinityforreddit.R;
+import ml.docilealligator.infinityforreddit.RedditDataRoomDatabase;
+import pl.droidsonroids.gif.GifImageView;
+import retrofit2.Retrofit;
+
+public class MultiRedditListingRecyclerViewAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {
+
+    private static final int VIEW_TYPE_FAVORITE_MULTI_REDDIT_DIVIDER = 0;
+    private static final int VIEW_TYPE_FAVORITE_MULTI_REDDIT = 1;
+    private static final int VIEW_TYPE_MULTI_REDDIT_DIVIDER = 2;
+    private static final int VIEW_TYPE_MULTI_REDDIT = 3;
+
+    private Context mContext;
+    private Retrofit mOauthRetrofit;
+    private RedditDataRoomDatabase mRedditDataRoomDatabase;
+    private RequestManager mGlide;
+
+    private String mAccessToken;
+    private List<MultiReddit> mMultiReddits;
+    private List<MultiReddit> mFavoriteMultiReddits;
+
+    public MultiRedditListingRecyclerViewAdapter(Context context, Retrofit oauthRetrofit,
+                                                 RedditDataRoomDatabase redditDataRoomDatabase,
+                                                 String accessToken) {
+        mContext = context;
+        mGlide = Glide.with(context.getApplicationContext());
+        mOauthRetrofit = oauthRetrofit;
+        mRedditDataRoomDatabase = redditDataRoomDatabase;
+        mAccessToken = accessToken;
+
+    }
+
+    @Override
+    public int getItemViewType(int position) {
+        if (mFavoriteMultiReddits != null && mFavoriteMultiReddits.size() > 0) {
+            if (position == 0) {
+                return VIEW_TYPE_FAVORITE_MULTI_REDDIT_DIVIDER;
+            } else if (position == mFavoriteMultiReddits.size() + 1) {
+                return VIEW_TYPE_MULTI_REDDIT_DIVIDER;
+            } else if (position <= mFavoriteMultiReddits.size()) {
+                return VIEW_TYPE_FAVORITE_MULTI_REDDIT;
+            } else {
+                return VIEW_TYPE_MULTI_REDDIT;
+            }
+        } else {
+            return VIEW_TYPE_MULTI_REDDIT;
+        }
+    }
+
+    @NonNull
+    @Override
+    public RecyclerView.ViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
+        switch (viewType) {
+            case VIEW_TYPE_FAVORITE_MULTI_REDDIT_DIVIDER:
+                return new FavoriteMultiRedditsDividerViewHolder(LayoutInflater.from(parent.getContext())
+                        .inflate(R.layout.item_favorite_thing_divider, parent, false));
+            case VIEW_TYPE_FAVORITE_MULTI_REDDIT:
+                return new FavoriteMultiRedditViewHolder(LayoutInflater.from(parent.getContext())
+                        .inflate(R.layout.item_multi_reddit, parent, false));
+            case VIEW_TYPE_MULTI_REDDIT_DIVIDER:
+                return new AllMultiRedditsDividerViewHolder(LayoutInflater.from(parent.getContext())
+                        .inflate(R.layout.item_favorite_thing_divider, parent, false));
+            default:
+                return new MultiRedditViewHolder(LayoutInflater.from(parent.getContext())
+                        .inflate(R.layout.item_multi_reddit, parent, false));
+        }
+    }
+
+    @Override
+    public void onBindViewHolder(@NonNull RecyclerView.ViewHolder holder, int position) {
+        if (holder instanceof MultiRedditViewHolder) {
+            String name;
+            String iconUrl;
+
+            int offset = (mFavoriteMultiReddits != null && mFavoriteMultiReddits.size() > 0) ?
+                    mFavoriteMultiReddits.size() + 2 : 0;
+
+            name = mMultiReddits.get(holder.getAdapterPosition() - offset).getName();
+            iconUrl = mMultiReddits.get(holder.getAdapterPosition() - offset).getIconUrl();
+            if(mMultiReddits.get(holder.getAdapterPosition() - offset).isFavorite()) {
+                ((MultiRedditViewHolder) holder).favoriteImageView.setImageResource(R.drawable.ic_favorite_24dp);
+            } else {
+                ((MultiRedditViewHolder) holder).favoriteImageView.setImageResource(R.drawable.ic_favorite_border_24dp);
+            }
+
+            ((MultiRedditViewHolder) holder).favoriteImageView.setOnClickListener(view -> {
+                if(mMultiReddits.get(holder.getAdapterPosition() - offset).isFavorite()) {
+                    ((MultiRedditViewHolder) holder).favoriteImageView.setImageResource(R.drawable.ic_favorite_border_24dp);
+                    mMultiReddits.get(holder.getAdapterPosition() - offset).setFavorite(false);
+                    FavoriteMultiReddit.favoriteMultiReddit(mOauthRetrofit, mRedditDataRoomDatabase, mAccessToken,
+                            false, mMultiReddits.get(holder.getAdapterPosition() - offset),
+                            new FavoriteMultiReddit.FavoriteMultiRedditListener() {
+                                @Override
+                                public void success() {
+                                    int position = holder.getAdapterPosition() - offset;
+                                    if(position >= 0 && mMultiReddits.size() > position) {
+                                        mMultiReddits.get(position).setFavorite(false);
+                                    }
+                                    ((MultiRedditViewHolder) holder).favoriteImageView.setImageResource(R.drawable.ic_favorite_border_24dp);
+                                }
+
+                                @Override
+                                public void failed() {
+                                    Toast.makeText(mContext, R.string.thing_unfavorite_failed, Toast.LENGTH_SHORT).show();
+                                    int position = holder.getAdapterPosition() - offset;
+                                    if(position >= 0 && mMultiReddits.size() > position) {
+                                        mMultiReddits.get(position).setFavorite(true);
+                                    }
+                                    ((MultiRedditViewHolder) holder).favoriteImageView.setImageResource(R.drawable.ic_favorite_24dp);
+                                }
+                            }
+                    );
+                } else {
+                    ((MultiRedditViewHolder) holder).favoriteImageView.setImageResource(R.drawable.ic_favorite_24dp);
+                    mMultiReddits.get(holder.getAdapterPosition() - offset).setFavorite(true);
+                    FavoriteMultiReddit.favoriteMultiReddit(mOauthRetrofit, mRedditDataRoomDatabase, mAccessToken,
+                            true, mMultiReddits.get(holder.getAdapterPosition() - offset),
+                            new FavoriteMultiReddit.FavoriteMultiRedditListener() {
+                                @Override
+                                public void success() {
+                                    int position = holder.getAdapterPosition() - offset;
+                                    if(position >= 0 && mMultiReddits.size() > position) {
+                                        mMultiReddits.get(position).setFavorite(true);
+                                    }
+                                    ((MultiRedditViewHolder) holder).favoriteImageView.setImageResource(R.drawable.ic_favorite_24dp);
+                                }
+
+                                @Override
+                                public void failed() {
+                                    Toast.makeText(mContext, R.string.thing_favorite_failed, Toast.LENGTH_SHORT).show();
+                                    int position = holder.getAdapterPosition() - offset;
+                                    if(position >= 0 && mMultiReddits.size() > position) {
+                                        mMultiReddits.get(position).setFavorite(false);
+                                    }
+                                    ((MultiRedditViewHolder) holder).favoriteImageView.setImageResource(R.drawable.ic_favorite_border_24dp);
+                                }
+                            }
+                    );
+                }
+            });
+            holder.itemView.setOnClickListener(view -> {
+                Intent intent = new Intent(mContext, ViewSubredditDetailActivity.class);
+                intent.putExtra(ViewSubredditDetailActivity.EXTRA_SUBREDDIT_NAME_KEY, name);
+                mContext.startActivity(intent);
+            });
+
+            if (iconUrl != null && !iconUrl.equals("")) {
+                mGlide.load(iconUrl)
+                        .apply(RequestOptions.bitmapTransform(new RoundedCornersTransformation(72, 0)))
+                        .error(mGlide.load(R.drawable.subreddit_default_icon)
+                                .apply(RequestOptions.bitmapTransform(new RoundedCornersTransformation(72, 0))))
+                        .into(((MultiRedditViewHolder) holder).iconImageView);
+            } else {
+                mGlide.load(R.drawable.subreddit_default_icon)
+                        .apply(RequestOptions.bitmapTransform(new RoundedCornersTransformation(72, 0)))
+                        .into(((MultiRedditViewHolder) holder).iconImageView);
+            }
+            ((MultiRedditViewHolder) holder).multiRedditNameTextView.setText(name);
+        } else if (holder instanceof FavoriteMultiRedditViewHolder) {
+            String name = mFavoriteMultiReddits.get(holder.getAdapterPosition() - 1).getName();
+            String iconUrl = mFavoriteMultiReddits.get(holder.getAdapterPosition() - 1).getIconUrl();
+            if(mFavoriteMultiReddits.get(holder.getAdapterPosition() - 1).isFavorite()) {
+                ((FavoriteMultiRedditViewHolder) holder).favoriteImageView.setImageResource(R.drawable.ic_favorite_24dp);
+            } else {
+                ((FavoriteMultiRedditViewHolder) holder).favoriteImageView.setImageResource(R.drawable.ic_favorite_border_24dp);
+            }
+
+            ((FavoriteMultiRedditViewHolder) holder).favoriteImageView.setOnClickListener(view -> {
+                if(mFavoriteMultiReddits.get(holder.getAdapterPosition() - 1).isFavorite()) {
+                    ((FavoriteMultiRedditViewHolder) holder).favoriteImageView.setImageResource(R.drawable.ic_favorite_border_24dp);
+                    mFavoriteMultiReddits.get(holder.getAdapterPosition() - 1).setFavorite(false);
+                    FavoriteMultiReddit.favoriteMultiReddit(mOauthRetrofit, mRedditDataRoomDatabase, mAccessToken,
+                            false, mFavoriteMultiReddits.get(holder.getAdapterPosition() - 1),
+                            new FavoriteMultiReddit.FavoriteMultiRedditListener() {
+                                @Override
+                                public void success() {
+                                    int position = holder.getAdapterPosition() - 1;
+                                    if(position >= 0 && mFavoriteMultiReddits.size() > position) {
+                                        mFavoriteMultiReddits.get(position).setFavorite(false);
+                                    }
+                                    ((FavoriteMultiRedditViewHolder) holder).favoriteImageView.setImageResource(R.drawable.ic_favorite_border_24dp);
+                                }
+
+                                @Override
+                                public void failed() {
+                                    Toast.makeText(mContext, R.string.thing_unfavorite_failed, Toast.LENGTH_SHORT).show();
+                                    int position = holder.getAdapterPosition() - 1;
+                                    if(position >= 0 && mFavoriteMultiReddits.size() > position) {
+                                        mFavoriteMultiReddits.get(position).setFavorite(true);
+                                    }
+                                    ((FavoriteMultiRedditViewHolder) holder).favoriteImageView.setImageResource(R.drawable.ic_favorite_24dp);
+                                }
+                            }
+                    );
+                } else {
+                    ((FavoriteMultiRedditViewHolder) holder).favoriteImageView.setImageResource(R.drawable.ic_favorite_24dp);
+                    mFavoriteMultiReddits.get(holder.getAdapterPosition() - 1).setFavorite(true);
+                    FavoriteMultiReddit.favoriteMultiReddit(mOauthRetrofit, mRedditDataRoomDatabase, mAccessToken,
+                            true, mFavoriteMultiReddits.get(holder.getAdapterPosition() - 1),
+                            new FavoriteMultiReddit.FavoriteMultiRedditListener() {
+                                @Override
+                                public void success() {
+                                    int position = holder.getAdapterPosition() - 1;
+                                    if(position >= 0 && mFavoriteMultiReddits.size() > position) {
+                                        mFavoriteMultiReddits.get(position).setFavorite(true);
+                                    }
+                                    ((FavoriteMultiRedditViewHolder) holder).favoriteImageView.setImageResource(R.drawable.ic_favorite_24dp);
+                                }
+
+                                @Override
+                                public void failed() {
+                                    Toast.makeText(mContext, R.string.thing_favorite_failed, Toast.LENGTH_SHORT).show();
+                                    int position = holder.getAdapterPosition() - 1;
+                                    if(position >= 0 && mFavoriteMultiReddits.size() > position) {
+                                        mFavoriteMultiReddits.get(position).setFavorite(false);
+                                    }
+                                    ((FavoriteMultiRedditViewHolder) holder).favoriteImageView.setImageResource(R.drawable.ic_favorite_border_24dp);
+                                }
+                            }
+                    );
+                }
+            });
+            holder.itemView.setOnClickListener(view -> {
+                Intent intent = new Intent(mContext, ViewSubredditDetailActivity.class);
+                intent.putExtra(ViewSubredditDetailActivity.EXTRA_SUBREDDIT_NAME_KEY, name);
+                mContext.startActivity(intent);
+            });
+
+            if (iconUrl != null && !iconUrl.equals("")) {
+                mGlide.load(iconUrl)
+                        .apply(RequestOptions.bitmapTransform(new RoundedCornersTransformation(72, 0)))
+                        .error(mGlide.load(R.drawable.subreddit_default_icon)
+                                .apply(RequestOptions.bitmapTransform(new RoundedCornersTransformation(72, 0))))
+                        .into(((FavoriteMultiRedditViewHolder) holder).iconImageView);
+            } else {
+                mGlide.load(R.drawable.subreddit_default_icon)
+                        .apply(RequestOptions.bitmapTransform(new RoundedCornersTransformation(72, 0)))
+                        .into(((FavoriteMultiRedditViewHolder) holder).iconImageView);
+            }
+            ((FavoriteMultiRedditViewHolder) holder).multiRedditNameTextView.setText(name);
+        }
+    }
+
+    @Override
+    public int getItemCount() {
+        if (mMultiReddits != null) {
+            if(mFavoriteMultiReddits != null && mFavoriteMultiReddits.size() > 0) {
+                return mMultiReddits.size() > 0 ?
+                        mFavoriteMultiReddits.size() + mMultiReddits.size() + 2 : 0;
+            }
+
+            return mMultiReddits.size();
+        }
+        return 0;
+    }
+
+    @Override
+    public void onViewRecycled(@NonNull RecyclerView.ViewHolder holder) {
+        if(holder instanceof MultiRedditViewHolder) {
+            mGlide.clear(((MultiRedditViewHolder) holder).iconImageView);
+        } else if (holder instanceof FavoriteMultiRedditViewHolder) {
+            mGlide.clear(((FavoriteMultiRedditViewHolder) holder).iconImageView);
+        }
+    }
+
+    public void setMultiReddits(List<MultiReddit> multiReddits) {
+        mMultiReddits = multiReddits;
+        notifyDataSetChanged();
+    }
+
+    public void setFavoriteMultiReddits(List<MultiReddit> favoriteMultiReddits) {
+        mFavoriteMultiReddits = favoriteMultiReddits;
+        notifyDataSetChanged();
+    }
+
+    class MultiRedditViewHolder extends RecyclerView.ViewHolder {
+        @BindView(R.id.multi_reddit_icon_gif_image_view_item_multi_reddit)
+        GifImageView iconImageView;
+        @BindView(R.id.multi_reddit_name_text_view_item_multi_reddit)
+        TextView multiRedditNameTextView;
+        @BindView(R.id.favorite_image_view_item_multi_reddit)
+        ImageView favoriteImageView;
+
+        MultiRedditViewHolder(@NonNull View itemView) {
+            super(itemView);
+            ButterKnife.bind(this, itemView);
+        }
+    }
+
+    class FavoriteMultiRedditViewHolder extends RecyclerView.ViewHolder {
+        @BindView(R.id.multi_reddit_icon_gif_image_view_item_multi_reddit)
+        GifImageView iconImageView;
+        @BindView(R.id.multi_reddit_name_text_view_item_multi_reddit)
+        TextView multiRedditNameTextView;
+        @BindView(R.id.favorite_image_view_item_multi_reddit)
+        ImageView favoriteImageView;
+
+        FavoriteMultiRedditViewHolder(View itemView) {
+            super(itemView);
+            ButterKnife.bind(this, itemView);
+        }
+    }
+
+    class FavoriteMultiRedditsDividerViewHolder extends RecyclerView.ViewHolder {
+        @BindView(R.id.divider_text_view_item_favorite_thing_divider) TextView dividerTextView;
+
+        FavoriteMultiRedditsDividerViewHolder(@NonNull View itemView) {
+            super(itemView);
+            ButterKnife.bind(this, itemView);
+            dividerTextView.setText(R.string.favorites);
+        }
+    }
+
+    class AllMultiRedditsDividerViewHolder extends RecyclerView.ViewHolder {
+        @BindView(R.id.divider_text_view_item_favorite_thing_divider) TextView dividerTextView;
+
+        AllMultiRedditsDividerViewHolder(@NonNull View itemView) {
+            super(itemView);
+            ButterKnife.bind(this, itemView);
+            dividerTextView.setText(R.string.all);
+        }
+    }
+}
diff --git a/app/src/main/java/ml/docilealligator/infinityforreddit/AppComponent.java b/app/src/main/java/ml/docilealligator/infinityforreddit/AppComponent.java
index 4ca67f58..33dd286e 100644
--- a/app/src/main/java/ml/docilealligator/infinityforreddit/AppComponent.java
+++ b/app/src/main/java/ml/docilealligator/infinityforreddit/AppComponent.java
@@ -12,6 +12,7 @@ import ml.docilealligator.infinityforreddit.Activity.FilteredThingActivity;
 import ml.docilealligator.infinityforreddit.Activity.LinkResolverActivity;
 import ml.docilealligator.infinityforreddit.Activity.LoginActivity;
 import ml.docilealligator.infinityforreddit.Activity.MainActivity;
+import ml.docilealligator.infinityforreddit.Activity.MultiRedditListingActivity;
 import ml.docilealligator.infinityforreddit.Activity.PostImageActivity;
 import ml.docilealligator.infinityforreddit.Activity.PostLinkActivity;
 import ml.docilealligator.infinityforreddit.Activity.PostTextActivity;
@@ -116,4 +117,6 @@ public interface AppComponent {
     void inject(ViewImageActivity viewImageActivity);
 
     void inject(ViewGIFActivity viewGIFActivity);
+
+    void inject(MultiRedditListingActivity multiRedditListingActivity);
 }
diff --git a/app/src/main/java/ml/docilealligator/infinityforreddit/AsyncTask/GetCurrentAccountAsyncTask.java b/app/src/main/java/ml/docilealligator/infinityforreddit/AsyncTask/GetCurrentAccountAsyncTask.java
index 2d9253b8..38d67e02 100644
--- a/app/src/main/java/ml/docilealligator/infinityforreddit/AsyncTask/GetCurrentAccountAsyncTask.java
+++ b/app/src/main/java/ml/docilealligator/infinityforreddit/AsyncTask/GetCurrentAccountAsyncTask.java
@@ -7,9 +7,10 @@ import ml.docilealligator.infinityforreddit.Account.AccountDao;
 
 public class GetCurrentAccountAsyncTask extends AsyncTask<Void, Void, Void> {
 
-    Account account;
-    AccountDao accountDao;
-    GetCurrentAccountAsyncTaskListener getCurrentAccountAsyncTaskListener;
+    private Account account;
+    private AccountDao accountDao;
+    private GetCurrentAccountAsyncTaskListener getCurrentAccountAsyncTaskListener;
+
     public GetCurrentAccountAsyncTask(AccountDao accountDao, GetCurrentAccountAsyncTaskListener getCurrentAccountAsyncTaskListener) {
         this.accountDao = accountDao;
         this.getCurrentAccountAsyncTaskListener = getCurrentAccountAsyncTaskListener;
diff --git a/app/src/main/java/ml/docilealligator/infinityforreddit/AsyncTask/InsertMultiRedditAsyncTask.java b/app/src/main/java/ml/docilealligator/infinityforreddit/AsyncTask/InsertMultiRedditAsyncTask.java
new file mode 100644
index 00000000..22613362
--- /dev/null
+++ b/app/src/main/java/ml/docilealligator/infinityforreddit/AsyncTask/InsertMultiRedditAsyncTask.java
@@ -0,0 +1,41 @@
+package ml.docilealligator.infinityforreddit.AsyncTask;
+
+import android.os.AsyncTask;
+
+import java.util.ArrayList;
+
+import ml.docilealligator.infinityforreddit.MultiReddit.MultiReddit;
+import ml.docilealligator.infinityforreddit.MultiReddit.MultiRedditDao;
+import ml.docilealligator.infinityforreddit.RedditDataRoomDatabase;
+
+public class InsertMultiRedditAsyncTask extends AsyncTask<Void, Void, Void> {
+    private MultiRedditDao multiRedditDao;
+    private ArrayList<MultiReddit> multiReddits;
+    private InsertMultiRedditAsyncTaskListener insertMultiRedditAsyncTaskListener;
+
+    public InsertMultiRedditAsyncTask(RedditDataRoomDatabase redditDataRoomDatabase,
+                                      ArrayList<MultiReddit> multiReddits,
+                                      InsertMultiRedditAsyncTaskListener insertMultiRedditAsyncTaskListener) {
+        multiRedditDao = redditDataRoomDatabase.multiRedditDao();
+        this.multiReddits = multiReddits;
+        this.insertMultiRedditAsyncTaskListener = insertMultiRedditAsyncTaskListener;
+    }
+
+    @Override
+    protected Void doInBackground(Void... voids) {
+        for (MultiReddit multiReddit : multiReddits) {
+            multiRedditDao.insert(multiReddit);
+        }
+        return null;
+    }
+
+    @Override
+    protected void onPostExecute(Void aVoid) {
+        super.onPostExecute(aVoid);
+        insertMultiRedditAsyncTaskListener.success();
+    }
+
+    public interface InsertMultiRedditAsyncTaskListener {
+        void success();
+    }
+}
diff --git a/app/src/main/java/ml/docilealligator/infinityforreddit/Fragment/FollowedUsersListingFragment.java b/app/src/main/java/ml/docilealligator/infinityforreddit/Fragment/FollowedUsersListingFragment.java
index 539aed91..43603177 100644
--- a/app/src/main/java/ml/docilealligator/infinityforreddit/Fragment/FollowedUsersListingFragment.java
+++ b/app/src/main/java/ml/docilealligator/infinityforreddit/Fragment/FollowedUsersListingFragment.java
@@ -52,9 +52,9 @@ public class FollowedUsersListingFragment extends Fragment {
     Retrofit mOauthRetrofit;
     @Inject
     RedditDataRoomDatabase mRedditDataRoomDatabase;
+    SubscribedUserViewModel mSubscribedUserViewModel;
     private Activity mActivity;
     private RequestManager mGlide;
-    private SubscribedUserViewModel mSubscribedUserViewModel;
 
     public FollowedUsersListingFragment() {
         // Required empty public constructor
diff --git a/app/src/main/java/ml/docilealligator/infinityforreddit/MultiReddit/FavoriteMultiReddit.java b/app/src/main/java/ml/docilealligator/infinityforreddit/MultiReddit/FavoriteMultiReddit.java
new file mode 100644
index 00000000..d05e917b
--- /dev/null
+++ b/app/src/main/java/ml/docilealligator/infinityforreddit/MultiReddit/FavoriteMultiReddit.java
@@ -0,0 +1,52 @@
+package ml.docilealligator.infinityforreddit.MultiReddit;
+
+import androidx.annotation.NonNull;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+
+import ml.docilealligator.infinityforreddit.AsyncTask.InsertMultiRedditAsyncTask;
+import ml.docilealligator.infinityforreddit.RedditAPI;
+import ml.docilealligator.infinityforreddit.RedditDataRoomDatabase;
+import ml.docilealligator.infinityforreddit.Utils.RedditUtils;
+import retrofit2.Call;
+import retrofit2.Callback;
+import retrofit2.Response;
+import retrofit2.Retrofit;
+
+public class FavoriteMultiReddit {
+    public interface FavoriteMultiRedditListener {
+        void success();
+        void failed();
+    }
+
+    public static void favoriteMultiReddit(Retrofit oauthRetrofit, RedditDataRoomDatabase redditDataRoomDatabase,
+                                           String accessToken, boolean makeFavorite, MultiReddit multiReddit,
+                                           FavoriteMultiRedditListener favoriteMultiRedditListener) {
+        Map<String, String> params = new HashMap<>();
+        params.put(RedditUtils.MULTIPATH_KEY, multiReddit.getPath());
+        params.put(RedditUtils.MAKE_FAVORITE_KEY, String.valueOf(makeFavorite));
+        params.put(RedditUtils.API_TYPE_KEY, RedditUtils.API_TYPE_JSON);
+        oauthRetrofit.create(RedditAPI.class).favoriteMultiReddit(RedditUtils.getOAuthHeader(accessToken),
+                params).enqueue(new Callback<String>() {
+            @Override
+            public void onResponse(@NonNull Call<String> call, @NonNull Response<String> response) {
+                if (response.isSuccessful()) {
+                    multiReddit.setFavorite(true);
+                    ArrayList<MultiReddit> singleMultiRedditList = new ArrayList<>();
+                    singleMultiRedditList.add(multiReddit);
+                    new InsertMultiRedditAsyncTask(redditDataRoomDatabase, singleMultiRedditList,
+                            favoriteMultiRedditListener::success).execute();
+                } else {
+                    favoriteMultiRedditListener.failed();
+                }
+            }
+
+            @Override
+            public void onFailure(@NonNull Call<String> call, @NonNull Throwable t) {
+                favoriteMultiRedditListener.failed();
+            }
+        });
+    }
+}
diff --git a/app/src/main/java/ml/docilealligator/infinityforreddit/MultiReddit/GetMultiReddit.java b/app/src/main/java/ml/docilealligator/infinityforreddit/MultiReddit/GetMultiReddit.java
new file mode 100644
index 00000000..bf90d4ab
--- /dev/null
+++ b/app/src/main/java/ml/docilealligator/infinityforreddit/MultiReddit/GetMultiReddit.java
@@ -0,0 +1,128 @@
+package ml.docilealligator.infinityforreddit.MultiReddit;
+
+import android.os.AsyncTask;
+
+import androidx.annotation.NonNull;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.ArrayList;
+
+import ml.docilealligator.infinityforreddit.RedditAPI;
+import ml.docilealligator.infinityforreddit.Utils.JSONUtils;
+import ml.docilealligator.infinityforreddit.Utils.RedditUtils;
+import retrofit2.Call;
+import retrofit2.Callback;
+import retrofit2.Response;
+import retrofit2.Retrofit;
+
+public class GetMultiReddit {
+    public interface GetMultiRedditListener {
+        void success(ArrayList<MultiReddit> multiReddits);
+        void failed();
+    }
+
+    public static void getMyMultiReddits(Retrofit oauthRetrofit, String accessToken, GetMultiRedditListener getMultiRedditListener) {
+        oauthRetrofit.create(RedditAPI.class)
+                .getMyMultiReddits(RedditUtils.getOAuthHeader(accessToken)).enqueue(new Callback<String>() {
+            @Override
+            public void onResponse(@NonNull Call<String> call, @NonNull Response<String> response) {
+                if (response.isSuccessful()) {
+                    new ParseMultiRedditsListAsyncTask(response.body(), new ParseMultiRedditsListAsyncTask.ParseMultiRedditsListAsyncTaskListener() {
+                        @Override
+                        public void success(ArrayList<MultiReddit> multiReddits) {
+                            getMultiRedditListener.success(multiReddits);
+                        }
+
+                        @Override
+                        public void failed() {
+                            getMultiRedditListener.failed();
+                        }
+                    }).execute();
+                } else {
+                    getMultiRedditListener.failed();
+                }
+            }
+
+            @Override
+            public void onFailure(@NonNull Call<String> call, @NonNull Throwable t) {
+                getMultiRedditListener.failed();
+            }
+        });
+    }
+
+    private static class ParseMultiRedditsListAsyncTask extends AsyncTask<Void, Void, Void> {
+        private JSONArray arrayResponse;
+        private boolean parseFailed;
+        private ArrayList<MultiReddit> multiReddits;
+        private ParseMultiRedditsListAsyncTaskListener parseMultiRedditsListAsyncTaskListener;
+
+        interface ParseMultiRedditsListAsyncTaskListener {
+            void success(ArrayList<MultiReddit> multiReddits);
+            void failed();
+        }
+
+        ParseMultiRedditsListAsyncTask(String response,
+                                       ParseMultiRedditsListAsyncTaskListener parseMultiRedditsListAsyncTaskListener) {
+            this.parseMultiRedditsListAsyncTaskListener = parseMultiRedditsListAsyncTaskListener;
+            try {
+                arrayResponse = new JSONArray(response);
+                multiReddits = new ArrayList<>();
+                parseFailed = false;
+            } catch (JSONException e) {
+                e.printStackTrace();
+                parseFailed = true;
+            }
+        }
+
+        @Override
+        protected Void doInBackground(Void... voids) {
+            if (!parseFailed) {
+                for (int i = 0; i < arrayResponse.length(); i++) {
+                    try {
+                        JSONObject singleMultiReddit = arrayResponse.getJSONObject(i).getJSONObject(JSONUtils.DATA_KEY);
+                        String displayName = singleMultiReddit.getString(JSONUtils.DISPLAY_NAME);
+                        String name = singleMultiReddit.getString(JSONUtils.NAME_KEY);
+                        String description = singleMultiReddit.getString(JSONUtils.DESCRIPTION_HTML_KEY);
+                        int nSubscribers = singleMultiReddit.getInt(JSONUtils.NUM_SUBSCRIBERS_KEY);
+                        String copiedFrom = singleMultiReddit.getString(JSONUtils.COPIED_FROM_KEY);
+                        String iconUrl = singleMultiReddit.getString(JSONUtils.ICON_URL_KEY);
+                        long createdUTC = singleMultiReddit.getLong(JSONUtils.CREATED_UTC_KEY);
+                        String visibility = singleMultiReddit.getString(JSONUtils.VISIBILITY_KEY);
+                        boolean over18 = singleMultiReddit.getBoolean(JSONUtils.OVER_18_KEY);
+                        String path = singleMultiReddit.getString(JSONUtils.PATH_KEY);
+                        String owner = singleMultiReddit.getString(JSONUtils.OWNER_KEY);
+                        boolean isSubscriber = singleMultiReddit.getBoolean(JSONUtils.IS_SUBSCRIBER_KEY);
+                        boolean isFavorited = singleMultiReddit.getBoolean(JSONUtils.IS_FAVORITED_KEY);
+
+                        JSONArray subredditsArray = singleMultiReddit.getJSONArray(JSONUtils.SUBREDDITS_KEY);
+                        ArrayList<String> subreddits = new ArrayList<>();
+                        for (int j = 0; j < subredditsArray.length(); j++) {
+                            subreddits.add(subredditsArray.getJSONObject(j).getString(JSONUtils.NAME_KEY));
+                        }
+
+                        MultiReddit multiReddit = new MultiReddit(path, displayName, name, description, copiedFrom,
+                                iconUrl, visibility, owner, nSubscribers, createdUTC, over18, isSubscriber,
+                                isFavorited, subreddits);
+                        multiReddits.add(multiReddit);
+                    } catch (JSONException e) {
+                        e.printStackTrace();
+                    }
+                }
+            }
+            return null;
+        }
+
+        @Override
+        protected void onPostExecute(Void aVoid) {
+            super.onPostExecute(aVoid);
+            if (!parseFailed) {
+                parseMultiRedditsListAsyncTaskListener.success(multiReddits);
+            } else {
+                parseMultiRedditsListAsyncTaskListener.failed();
+            }
+        }
+    }
+}
diff --git a/app/src/main/java/ml/docilealligator/infinityforreddit/MultiReddit/MultiReddit.java b/app/src/main/java/ml/docilealligator/infinityforreddit/MultiReddit/MultiReddit.java
new file mode 100644
index 00000000..4692c8d4
--- /dev/null
+++ b/app/src/main/java/ml/docilealligator/infinityforreddit/MultiReddit/MultiReddit.java
@@ -0,0 +1,201 @@
+package ml.docilealligator.infinityforreddit.MultiReddit;
+
+import androidx.annotation.NonNull;
+import androidx.room.ColumnInfo;
+import androidx.room.Entity;
+import androidx.room.ForeignKey;
+import androidx.room.Ignore;
+
+import java.util.ArrayList;
+
+import ml.docilealligator.infinityforreddit.Account.Account;
+
+@Entity(tableName = "multi_reddits", primaryKeys = {"path", "username"},
+        foreignKeys = @ForeignKey(entity = Account.class, parentColumns = "username",
+                childColumns = "username", onDelete = ForeignKey.CASCADE))
+public class MultiReddit {
+    @NonNull
+    @ColumnInfo(name = "path")
+    private String path;
+    @NonNull
+    @ColumnInfo(name = "display_name")
+    private String displayName;
+    @NonNull
+    @ColumnInfo(name = "name")
+    private String name;
+    @ColumnInfo(name = "description")
+    private String description;
+    @ColumnInfo(name = "copied_from")
+    private String copiedFrom;
+    @ColumnInfo(name = "icon_url")
+    private String iconUrl;
+    @ColumnInfo(name = "visibility")
+    private String visibility;
+    @NonNull
+    @ColumnInfo(name = "username")
+    private String owner;
+    @ColumnInfo(name = "n_subscribers")
+    private int nSubscribers;
+    @ColumnInfo(name = "created_UTC")
+    private long createdUTC;
+    @ColumnInfo(name = "over_18")
+    private boolean over18;
+    @ColumnInfo(name = "is_subscriber")
+    private boolean isSubscriber;
+    @ColumnInfo(name = "is_favorite")
+    private boolean isFavorite;
+    @Ignore
+    private ArrayList<String> subreddits;
+
+    public MultiReddit(@NonNull String path, @NonNull String displayName, @NonNull String name,
+                       String description, String copiedFrom, String iconUrl, String visibility,
+                       @NonNull String owner, int nSubscribers, long createdUTC, boolean over18,
+                       boolean isSubscriber, boolean isFavorite) {
+        this.displayName = displayName;
+        this.name = name;
+        this.description = description;
+        this.copiedFrom = copiedFrom;
+        this.iconUrl = iconUrl;
+        this.visibility = visibility;
+        this.path = path;
+        this.owner = owner;
+        this.nSubscribers = nSubscribers;
+        this.createdUTC = createdUTC;
+        this.over18 = over18;
+        this.isSubscriber = isSubscriber;
+        this.isFavorite = isFavorite;
+    }
+
+    public MultiReddit(@NonNull String path, String displayName, String name, String description, String copiedFrom,
+                       String iconUrl, String visibility, @NonNull String owner,
+                       int nSubscribers, long createdUTC, boolean over18, boolean isSubscriber,
+                       boolean isFavorite, ArrayList<String> subreddits) {
+        this.displayName = displayName;
+        this.name = name;
+        this.description = description;
+        this.copiedFrom = copiedFrom;
+        this.iconUrl = iconUrl;
+        this.visibility = visibility;
+        this.path = path;
+        this.owner = owner;
+        this.nSubscribers = nSubscribers;
+        this.createdUTC = createdUTC;
+        this.over18 = over18;
+        this.isSubscriber = isSubscriber;
+        this.isFavorite = isFavorite;
+        this.subreddits = subreddits;
+    }
+
+    @NonNull
+    public String getPath() {
+        return path;
+    }
+
+    public void setPath(@NonNull String path) {
+        this.path = path;
+    }
+
+    public String getDisplayName() {
+        return displayName;
+    }
+
+    public void setDisplayName(String displayName) {
+        this.displayName = displayName;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    public String getCopiedFrom() {
+        return copiedFrom;
+    }
+
+    public void setCopiedFrom(String copiedFrom) {
+        this.copiedFrom = copiedFrom;
+    }
+
+    public String getIconUrl() {
+        return iconUrl;
+    }
+
+    public void setIconUrl(String iconUrl) {
+        this.iconUrl = iconUrl;
+    }
+
+    public String getVisibility() {
+        return visibility;
+    }
+
+    public void setVisibility(String visibility) {
+        this.visibility = visibility;
+    }
+
+    public String getOwner() {
+        return owner;
+    }
+
+    public void setOwner(String owner) {
+        this.owner = owner;
+    }
+
+    public int getNSubscribers() {
+        return nSubscribers;
+    }
+
+    public void setNSubscribers(int nSubscribers) {
+        this.nSubscribers = nSubscribers;
+    }
+
+    public long getCreatedUTC() {
+        return createdUTC;
+    }
+
+    public void setCreatedUTC(long createdUTC) {
+        this.createdUTC = createdUTC;
+    }
+
+    public boolean isOver18() {
+        return over18;
+    }
+
+    public void setOver18(boolean over18) {
+        this.over18 = over18;
+    }
+
+    public boolean isSubscriber() {
+        return isSubscriber;
+    }
+
+    public void setSubscriber(boolean subscriber) {
+        isSubscriber = subscriber;
+    }
+
+    public boolean isFavorite() {
+        return isFavorite;
+    }
+
+    public void setFavorite(boolean favorite) {
+        isFavorite = favorite;
+    }
+
+    public ArrayList<String> getSubreddits() {
+        return subreddits;
+    }
+
+    public void setSubreddits(ArrayList<String> subreddits) {
+        this.subreddits = subreddits;
+    }
+}
diff --git a/app/src/main/java/ml/docilealligator/infinityforreddit/MultiReddit/MultiRedditDao.java b/app/src/main/java/ml/docilealligator/infinityforreddit/MultiReddit/MultiRedditDao.java
new file mode 100644
index 00000000..1e72966d
--- /dev/null
+++ b/app/src/main/java/ml/docilealligator/infinityforreddit/MultiReddit/MultiRedditDao.java
@@ -0,0 +1,27 @@
+package ml.docilealligator.infinityforreddit.MultiReddit;
+
+import androidx.lifecycle.LiveData;
+import androidx.room.Dao;
+import androidx.room.Insert;
+import androidx.room.OnConflictStrategy;
+import androidx.room.Query;
+
+import java.util.List;
+
+@Dao
+public interface MultiRedditDao {
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    void insert(MultiReddit MultiReddit);
+
+    @Query("SELECT * FROM multi_reddits WHERE username = :username ORDER BY name COLLATE NOCASE ASC")
+    LiveData<List<MultiReddit>> getAllMultiReddits(String username);
+
+    @Query("SELECT * FROM multi_reddits WHERE username = :username AND is_favorite ORDER BY name COLLATE NOCASE ASC")
+    LiveData<List<MultiReddit>> getAllFavoriteMultiReddits(String username);
+
+    @Query("SELECT * FROM multi_reddits WHERE name = :name AND username = :username COLLATE NOCASE LIMIT 1")
+    MultiReddit getMultiReddit(String name, String username);
+
+    @Query("DELETE FROM multi_reddits WHERE name = :name AND username = :username")
+    void deleteMultiReddit(String name, String username);
+}
diff --git a/app/src/main/java/ml/docilealligator/infinityforreddit/MultiReddit/MultiRedditRepository.java b/app/src/main/java/ml/docilealligator/infinityforreddit/MultiReddit/MultiRedditRepository.java
new file mode 100644
index 00000000..b725caa2
--- /dev/null
+++ b/app/src/main/java/ml/docilealligator/infinityforreddit/MultiReddit/MultiRedditRepository.java
@@ -0,0 +1,48 @@
+package ml.docilealligator.infinityforreddit.MultiReddit;
+
+import android.os.AsyncTask;
+
+import androidx.lifecycle.LiveData;
+
+import java.util.List;
+
+import ml.docilealligator.infinityforreddit.RedditDataRoomDatabase;
+
+public class MultiRedditRepository {
+    private MultiRedditDao mMultiRedditDao;
+    private LiveData<List<MultiReddit>> mAllMultiReddits;
+    private LiveData<List<MultiReddit>> mAllFavoriteMultiReddits;
+
+    MultiRedditRepository(RedditDataRoomDatabase redditDataRoomDatabase, String accountName) {
+        mMultiRedditDao = redditDataRoomDatabase.multiRedditDao();
+        mAllMultiReddits = mMultiRedditDao.getAllMultiReddits(accountName);
+        mAllFavoriteMultiReddits = mMultiRedditDao.getAllFavoriteMultiReddits(accountName);
+    }
+
+    LiveData<List<MultiReddit>> getAllMultiReddits() {
+        return mAllMultiReddits;
+    }
+
+    LiveData<List<MultiReddit>> getAllFavoriteMultiReddits() {
+        return mAllFavoriteMultiReddits;
+    }
+
+    public void insert(MultiReddit MultiReddit) {
+        new MultiRedditRepository.insertAsyncTask(mMultiRedditDao).execute();
+    }
+
+    private static class insertAsyncTask extends AsyncTask<MultiReddit, Void, Void> {
+
+        private MultiRedditDao mAsyncTaskDao;
+
+        insertAsyncTask(MultiRedditDao dao) {
+            mAsyncTaskDao = dao;
+        }
+
+        @Override
+        protected Void doInBackground(final MultiReddit... params) {
+            mAsyncTaskDao.insert(params[0]);
+            return null;
+        }
+    }
+}
diff --git a/app/src/main/java/ml/docilealligator/infinityforreddit/MultiReddit/MultiRedditViewModel.java b/app/src/main/java/ml/docilealligator/infinityforreddit/MultiReddit/MultiRedditViewModel.java
new file mode 100644
index 00000000..bb9dcf76
--- /dev/null
+++ b/app/src/main/java/ml/docilealligator/infinityforreddit/MultiReddit/MultiRedditViewModel.java
@@ -0,0 +1,56 @@
+package ml.docilealligator.infinityforreddit.MultiReddit;
+
+import android.app.Application;
+
+import androidx.annotation.NonNull;
+import androidx.lifecycle.AndroidViewModel;
+import androidx.lifecycle.LiveData;
+import androidx.lifecycle.ViewModel;
+import androidx.lifecycle.ViewModelProvider;
+
+import java.util.List;
+
+import ml.docilealligator.infinityforreddit.RedditDataRoomDatabase;
+
+public class MultiRedditViewModel extends AndroidViewModel {
+    private MultiRedditRepository mMultiRedditRepository;
+    private LiveData<List<MultiReddit>> mAllMultiReddits;
+    private LiveData<List<MultiReddit>> mAllFavoriteMultiReddits;
+
+    public MultiRedditViewModel(Application application, RedditDataRoomDatabase redditDataRoomDatabase, String accountName) {
+        super(application);
+        mMultiRedditRepository = new MultiRedditRepository(redditDataRoomDatabase, accountName);
+        mAllMultiReddits = mMultiRedditRepository.getAllMultiReddits();
+        mAllFavoriteMultiReddits = mMultiRedditRepository.getAllFavoriteMultiReddits();
+    }
+
+    public LiveData<List<MultiReddit>> getAllMultiReddits() {
+        return mAllMultiReddits;
+    }
+
+    public LiveData<List<MultiReddit>> getAllFavoriteMultiReddits() {
+        return mAllFavoriteMultiReddits;
+    }
+
+    public void insert(MultiReddit MultiReddit) {
+        mMultiRedditRepository.insert(MultiReddit);
+    }
+
+    public static class Factory extends ViewModelProvider.NewInstanceFactory {
+        private Application mApplication;
+        private RedditDataRoomDatabase mRedditDataRoomDatabase;
+        private String mAccountName;
+
+        public Factory(Application application, RedditDataRoomDatabase redditDataRoomDatabase, String accountName) {
+            mApplication = application;
+            mRedditDataRoomDatabase = redditDataRoomDatabase;
+            mAccountName = accountName;
+        }
+
+        @NonNull
+        @Override
+        public <T extends ViewModel> T create(@NonNull Class<T> modelClass) {
+            return (T) new MultiRedditViewModel(mApplication, mRedditDataRoomDatabase, mAccountName);
+        }
+    }
+}
diff --git a/app/src/main/java/ml/docilealligator/infinityforreddit/RedditAPI.java b/app/src/main/java/ml/docilealligator/infinityforreddit/RedditAPI.java
index 52fdb0ed..9097b026 100644
--- a/app/src/main/java/ml/docilealligator/infinityforreddit/RedditAPI.java
+++ b/app/src/main/java/ml/docilealligator/infinityforreddit/RedditAPI.java
@@ -261,4 +261,11 @@ public interface RedditAPI {
     @FormUrlEncoded
     @POST("/api/favorite")
     Call<String> favoriteThing(@HeaderMap Map<String, String> headers, @FieldMap Map<String, String> params);
+
+    @GET("/api/multi/mine")
+    Call<String> getMyMultiReddits(@HeaderMap Map<String, String> headers);
+
+    @FormUrlEncoded
+    @POST("/api/multi/favorite?raw_json=1&gilding_detail=1")
+    Call<String> favoriteMultiReddit(@HeaderMap Map<String, String> headers, @FieldMap Map<String, String> params);
 }
diff --git a/app/src/main/java/ml/docilealligator/infinityforreddit/RedditDataRoomDatabase.java b/app/src/main/java/ml/docilealligator/infinityforreddit/RedditDataRoomDatabase.java
index 7953ae75..df94d020 100644
--- a/app/src/main/java/ml/docilealligator/infinityforreddit/RedditDataRoomDatabase.java
+++ b/app/src/main/java/ml/docilealligator/infinityforreddit/RedditDataRoomDatabase.java
@@ -11,6 +11,8 @@ import androidx.sqlite.db.SupportSQLiteDatabase;
 
 import ml.docilealligator.infinityforreddit.Account.Account;
 import ml.docilealligator.infinityforreddit.Account.AccountDao;
+import ml.docilealligator.infinityforreddit.MultiReddit.MultiReddit;
+import ml.docilealligator.infinityforreddit.MultiReddit.MultiRedditDao;
 import ml.docilealligator.infinityforreddit.SubredditDatabase.SubredditDao;
 import ml.docilealligator.infinityforreddit.SubredditDatabase.SubredditData;
 import ml.docilealligator.infinityforreddit.SubscribedSubredditDatabase.SubscribedSubredditDao;
@@ -20,7 +22,8 @@ import ml.docilealligator.infinityforreddit.SubscribedUserDatabase.SubscribedUse
 import ml.docilealligator.infinityforreddit.User.UserDao;
 import ml.docilealligator.infinityforreddit.User.UserData;
 
-@Database(entities = {Account.class, SubredditData.class, SubscribedSubredditData.class, UserData.class, SubscribedUserData.class}, version = 3)
+@Database(entities = {Account.class, SubredditData.class, SubscribedSubredditData.class, UserData.class,
+        SubscribedUserData.class, MultiReddit.class}, version = 4)
 public abstract class RedditDataRoomDatabase extends RoomDatabase {
     private static RedditDataRoomDatabase INSTANCE;
 
@@ -30,7 +33,7 @@ public abstract class RedditDataRoomDatabase extends RoomDatabase {
                 if (INSTANCE == null) {
                     INSTANCE = Room.databaseBuilder(context.getApplicationContext(),
                             RedditDataRoomDatabase.class, "reddit_data")
-                            .addMigrations(MIGRATION_1_2, MIGRATION_2_3)
+                            .addMigrations(MIGRATION_1_2, MIGRATION_2_3, MIGRATION_3_4)
                             .build();
                 }
             }
@@ -48,6 +51,8 @@ public abstract class RedditDataRoomDatabase extends RoomDatabase {
 
     public abstract SubscribedUserDao subscribedUserDao();
 
+    public abstract MultiRedditDao multiRedditDao();
+
     private static final Migration MIGRATION_1_2 = new Migration(1, 2) {
         @Override
         public void migrate(SupportSQLiteDatabase database) {
@@ -80,4 +85,17 @@ public abstract class RedditDataRoomDatabase extends RoomDatabase {
             database.execSQL("ALTER TABLE subscribed_users_temp RENAME TO subscribed_users");
         }
     };
+
+    private static final Migration MIGRATION_3_4 = new Migration(3, 4) {
+        @Override
+        public void migrate(@NonNull SupportSQLiteDatabase database) {
+            database.execSQL("CREATE TABLE multi_reddits" +
+                    "(path TEXT NOT NULL, username TEXT NOT NULL, name TEXT NOT NULL, " +
+                    "display_name TEXT NOT NULL, description TEXT, copied_from TEXT, " +
+                    "n_subscribers INTEGER NOT NULL, icon_url TEXT, created_UTC INTEGER NOT NULL, " +
+                    "visibility TEXT, over_18 INTEGER NOT NULL, is_subscriber INTEGER NOT NULL, " +
+                    "is_favorite INTEGER NOT NULL, PRIMARY KEY(path, username), " +
+                    "FOREIGN KEY(username) REFERENCES accounts(username) ON DELETE CASCADE)");
+        }
+    };
 }
diff --git a/app/src/main/java/ml/docilealligator/infinityforreddit/SubscribedUserDatabase/SubscribedUserDao.java b/app/src/main/java/ml/docilealligator/infinityforreddit/SubscribedUserDatabase/SubscribedUserDao.java
index 33ecac48..c085f298 100644
--- a/app/src/main/java/ml/docilealligator/infinityforreddit/SubscribedUserDatabase/SubscribedUserDao.java
+++ b/app/src/main/java/ml/docilealligator/infinityforreddit/SubscribedUserDatabase/SubscribedUserDao.java
@@ -13,9 +13,6 @@ public interface SubscribedUserDao {
     @Insert(onConflict = OnConflictStrategy.REPLACE)
     void insert(SubscribedUserData subscribedUserData);
 
-    @Query("DELETE FROM subscribed_users")
-    void deleteAllSubscribedUsers();
-
     @Query("SELECT * FROM subscribed_users WHERE username = :accountName ORDER BY name COLLATE NOCASE ASC")
     LiveData<List<SubscribedUserData>> getAllSubscribedUsers(String accountName);
 
diff --git a/app/src/main/java/ml/docilealligator/infinityforreddit/Utils/JSONUtils.java b/app/src/main/java/ml/docilealligator/infinityforreddit/Utils/JSONUtils.java
index d0979f5e..91babc40 100644
--- a/app/src/main/java/ml/docilealligator/infinityforreddit/Utils/JSONUtils.java
+++ b/app/src/main/java/ml/docilealligator/infinityforreddit/Utils/JSONUtils.java
@@ -53,6 +53,7 @@ public class JSONUtils {
     public static final String BANNER_IMG_KEY = "banner_img";
     public static final String BANNER_BACKGROUND_IMAGE_KEY = "banner_background_image";
     public static final String ICON_IMG_KEY = "icon_img";
+    public static final String ICON_URL_KEY = "icon_url";
     public static final String COMMUNITY_ICON_KEY = "community_icon";
     public static final String LINK_KARMA_KEY = "link_karma";
     public static final String COMMENT_KARMA_KEY = "comment_karma";
@@ -77,6 +78,7 @@ public class JSONUtils {
     public static final String RULES_KEY = "rules";
     public static final String SHORT_NAME_KEY = "short_name";
     public static final String DESCRIPTION_KEY = "description";
+    public static final String DESCRIPTION_HTML_KEY = "description_html";
     public static final String ARCHIVED_KEY = "archived";
     public static final String LOCKEC_KEY = "locked";
     public static final String SAVED_KEY = "saved";
@@ -90,4 +92,13 @@ public class JSONUtils {
     public static final String HIDDEN_KEY = "hidden";
     public static final String USER_HAS_FAVORITED_KEY = "user_has_favorited";
     public static final String RESOLUTIONS_KEY = "resolutions";
+    public static final String NUM_SUBSCRIBERS_KEY = "num_subscribers";
+    public static final String COPIED_FROM_KEY = "copied_from";
+    public static final String VISIBILITY_KEY = "visibility";
+    public static final String OVER_18_KEY = "over_18";
+    public static final String OWNER_KEY = "owner";
+    public static final String IS_SUBSCRIBER_KEY = "is_subscriber";
+    public static final String IS_FAVORITED_KEY = "is_favorited";
+    public static final String SUBREDDITS_KEY = "subreddits";
+    public static final String PATH_KEY = "path";
 }
diff --git a/app/src/main/java/ml/docilealligator/infinityforreddit/Utils/RedditUtils.java b/app/src/main/java/ml/docilealligator/infinityforreddit/Utils/RedditUtils.java
index 000178e4..28faaf6d 100644
--- a/app/src/main/java/ml/docilealligator/infinityforreddit/Utils/RedditUtils.java
+++ b/app/src/main/java/ml/docilealligator/infinityforreddit/Utils/RedditUtils.java
@@ -81,6 +81,8 @@ public class RedditUtils {
 
     public static final String MAKE_FAVORITE_KEY = "make_favorite";
 
+    public static final String MULTIPATH_KEY = "multipath";
+
     public static Map<String, String> getHttpBasicAuthHeader() {
         Map<String, String> params = new HashMap<>();
         String credentials = String.format("%s:%s", RedditUtils.CLIENT_ID, "");