Continue adding submitting gallery posts support.

3 files changed, 461 insertions, 55 deletions

diff --git a/app/src/main/java/ml/docilealligator/infinityforreddit/AppComponent.java b/app/src/main/java/ml/docilealligator/infinityforreddit/AppComponent.java
index fe68ecd4..c83108a8 100644
--- a/app/src/main/java/ml/docilealligator/infinityforreddit/AppComponent.java
+++ b/app/src/main/java/ml/docilealligator/infinityforreddit/AppComponent.java
@@ -27,6 +27,7 @@ import ml.docilealligator.infinityforreddit.activities.MainActivity;
 import ml.docilealligator.infinityforreddit.activities.MultiredditSelectionActivity;
 import ml.docilealligator.infinityforreddit.activities.PostFilterPreferenceActivity;
 import ml.docilealligator.infinityforreddit.activities.PostFilterUsageListingActivity;
+import ml.docilealligator.infinityforreddit.activities.PostGalleryActivity;
 import ml.docilealligator.infinityforreddit.activities.PostImageActivity;
 import ml.docilealligator.infinityforreddit.activities.PostLinkActivity;
 import ml.docilealligator.infinityforreddit.activities.PostTextActivity;
@@ -275,4 +276,6 @@ public interface AppComponent {
     void inject(RPANActivity rpanActivity);
 
     void inject(ViewRPANBroadcastFragment viewRPANBroadcastFragment);
+
+    void inject(PostGalleryActivity postGalleryActivity);
 }
diff --git a/app/src/main/java/ml/docilealligator/infinityforreddit/activities/PostGalleryActivity.java b/app/src/main/java/ml/docilealligator/infinityforreddit/activities/PostGalleryActivity.java
index c70957f6..83118caf 100644
--- a/app/src/main/java/ml/docilealligator/infinityforreddit/activities/PostGalleryActivity.java
+++ b/app/src/main/java/ml/docilealligator/infinityforreddit/activities/PostGalleryActivity.java
@@ -1,37 +1,57 @@
 package ml.docilealligator.infinityforreddit.activities;
 
+import android.content.Intent;
 import android.content.SharedPreferences;
 import android.content.res.Resources;
 import android.net.Uri;
+import android.os.Build;
 import android.os.Bundle;
+import android.os.Handler;
 import android.view.Menu;
+import android.view.MenuItem;
 import android.view.View;
 import android.widget.EditText;
 import android.widget.LinearLayout;
 import android.widget.TextView;
 
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import androidx.appcompat.widget.Toolbar;
 import androidx.coordinatorlayout.widget.CoordinatorLayout;
+import androidx.core.content.ContextCompat;
 import androidx.recyclerview.widget.RecyclerView;
 
+import com.bumptech.glide.Glide;
 import com.bumptech.glide.RequestManager;
+import com.bumptech.glide.request.RequestOptions;
 import com.google.android.material.appbar.AppBarLayout;
 import com.google.android.material.button.MaterialButton;
+import com.google.android.material.dialog.MaterialAlertDialogBuilder;
 import com.google.android.material.snackbar.Snackbar;
 import com.google.android.material.switchmaterial.SwitchMaterial;
 import com.libRG.CustomTextView;
 
+import org.greenrobot.eventbus.EventBus;
+import org.greenrobot.eventbus.Subscribe;
+
 import java.util.concurrent.Executor;
 
 import javax.inject.Inject;
 import javax.inject.Named;
 
 import butterknife.BindView;
+import butterknife.ButterKnife;
+import jp.wasabeef.glide.transformations.RoundedCornersTransformation;
 import ml.docilealligator.infinityforreddit.Flair;
+import ml.docilealligator.infinityforreddit.Infinity;
 import ml.docilealligator.infinityforreddit.R;
 import ml.docilealligator.infinityforreddit.RedditDataRoomDatabase;
+import ml.docilealligator.infinityforreddit.asynctasks.LoadSubredditIcon;
 import ml.docilealligator.infinityforreddit.bottomsheetfragments.FlairBottomSheetFragment;
 import ml.docilealligator.infinityforreddit.customtheme.CustomThemeWrapper;
+import ml.docilealligator.infinityforreddit.events.SwitchAccountEvent;
+import ml.docilealligator.infinityforreddit.services.SubmitPostService;
+import ml.docilealligator.infinityforreddit.utils.SharedPreferencesUtils;
 import pl.droidsonroids.gif.GifImageView;
 import retrofit2.Retrofit;
 
@@ -118,7 +138,6 @@ public class PostGalleryActivity extends BaseActivity implements FlairBottomShee
     private boolean subredditIsUser;
     private boolean loadSubredditIconSuccessful = true;
     private boolean isPosting;
-    private Uri imageUri;
     private int primaryTextColor;
     private int flairBackgroundColor;
     private int flairTextColor;
@@ -137,27 +156,411 @@ public class PostGalleryActivity extends BaseActivity implements FlairBottomShee
 
     @Override
     protected void onCreate(Bundle savedInstanceState) {
+        ((Infinity) getApplication()).getAppComponent().inject(this);
+
+        setImmersiveModeNotApplicable();
+
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_post_gallery);
+
+        ButterKnife.bind(this);
+
+        EventBus.getDefault().register(this);
+
+        applyCustomTheme();
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && isChangeStatusBarIconColor()) {
+            addOnOffsetChangedListener(appBarLayout);
+        }
+
+        setSupportActionBar(toolbar);
+        getSupportActionBar().setDisplayHomeAsUpEnabled(true);
+
+        mGlide = Glide.with(this);
+
+        mPostingSnackbar = Snackbar.make(coordinatorLayout, R.string.posting, Snackbar.LENGTH_INDEFINITE);
+
+        resources = getResources();
+
+        mAccessToken = mCurrentAccountSharedPreferences.getString(SharedPreferencesUtils.ACCESS_TOKEN, null);
+        mAccountName = mCurrentAccountSharedPreferences.getString(SharedPreferencesUtils.ACCOUNT_NAME, null);
+
+        if (savedInstanceState != null) {
+            subredditName = savedInstanceState.getString(SUBREDDIT_NAME_STATE);
+            iconUrl = savedInstanceState.getString(SUBREDDIT_ICON_STATE);
+            subredditSelected = savedInstanceState.getBoolean(SUBREDDIT_SELECTED_STATE);
+            subredditIsUser = savedInstanceState.getBoolean(SUBREDDIT_IS_USER_STATE);
+            loadSubredditIconSuccessful = savedInstanceState.getBoolean(LOAD_SUBREDDIT_ICON_STATE);
+            isPosting = savedInstanceState.getBoolean(IS_POSTING_STATE);
+            flair = savedInstanceState.getParcelable(FLAIR_STATE);
+            isSpoiler = savedInstanceState.getBoolean(IS_SPOILER_STATE);
+            isNSFW = savedInstanceState.getBoolean(IS_NSFW_STATE);
+
+            if (savedInstanceState.getString(IMAGE_URI_STATE) != null) {
+                imageUri = Uri.parse(savedInstanceState.getString(IMAGE_URI_STATE));
+                loadImage();
+            }
+
+            if (subredditName != null) {
+                subredditNameTextView.setTextColor(primaryTextColor);
+                subredditNameTextView.setText(subredditName);
+                flairTextView.setVisibility(View.VISIBLE);
+                if (!loadSubredditIconSuccessful) {
+                    loadSubredditIcon();
+                }
+            }
+            displaySubredditIcon();
+
+            if (isPosting) {
+                mPostingSnackbar.show();
+            }
+
+            if (flair != null) {
+                flairTextView.setText(flair.getText());
+                flairTextView.setBackgroundColor(flairBackgroundColor);
+                flairTextView.setBorderColor(flairBackgroundColor);
+                flairTextView.setTextColor(flairTextColor);
+            }
+            if (isSpoiler) {
+                spoilerTextView.setBackgroundColor(spoilerBackgroundColor);
+                spoilerTextView.setBorderColor(spoilerBackgroundColor);
+                spoilerTextView.setTextColor(spoilerTextColor);
+            }
+            if (isNSFW) {
+                nsfwTextView.setBackgroundColor(nsfwBackgroundColor);
+                nsfwTextView.setBorderColor(nsfwBackgroundColor);
+                nsfwTextView.setTextColor(nsfwTextColor);
+            }
+        } else {
+            isPosting = false;
+
+            if (getIntent().hasExtra(EXTRA_SUBREDDIT_NAME)) {
+                loadSubredditIconSuccessful = false;
+                subredditName = getIntent().getStringExtra(EXTRA_SUBREDDIT_NAME);
+                subredditSelected = true;
+                subredditNameTextView.setTextColor(primaryTextColor);
+                subredditNameTextView.setText(subredditName);
+                flairTextView.setVisibility(View.VISIBLE);
+                loadSubredditIcon();
+            } else {
+                mGlide.load(R.drawable.subreddit_default_icon)
+                        .apply(RequestOptions.bitmapTransform(new RoundedCornersTransformation(72, 0)))
+                        .into(iconGifImageView);
+            }
+
+            imageUri = getIntent().getData();
+            if (imageUri != null) {
+                loadImage();
+            }
+        }
+
+        iconGifImageView.setOnClickListener(view -> {
+            Intent intent = new Intent(this, SubredditSelectionActivity.class);
+            startActivityForResult(intent, SUBREDDIT_SELECTION_REQUEST_CODE);
+        });
+
+        subredditNameTextView.setOnClickListener(view -> {
+            Intent intent = new Intent(this, SubredditSelectionActivity.class);
+            startActivityForResult(intent, SUBREDDIT_SELECTION_REQUEST_CODE);
+        });
+
+        rulesButton.setOnClickListener(view -> {
+            if (subredditName == null) {
+                Snackbar.make(coordinatorLayout, R.string.select_a_subreddit, Snackbar.LENGTH_SHORT).show();
+            } else {
+                Intent intent = new Intent(this, RulesActivity.class);
+                if (subredditIsUser) {
+                    intent.putExtra(RulesActivity.EXTRA_SUBREDDIT_NAME, "u_" + subredditName);
+                } else {
+                    intent.putExtra(RulesActivity.EXTRA_SUBREDDIT_NAME, subredditName);
+                }
+                startActivity(intent);
+            }
+        });
+
+        flairTextView.setOnClickListener(view -> {
+            if (flair == null) {
+                flairSelectionBottomSheetFragment = new FlairBottomSheetFragment();
+                Bundle bundle = new Bundle();
+                bundle.putString(FlairBottomSheetFragment.EXTRA_ACCESS_TOKEN, mAccessToken);
+                bundle.putString(FlairBottomSheetFragment.EXTRA_SUBREDDIT_NAME, subredditName);
+                flairSelectionBottomSheetFragment.setArguments(bundle);
+                flairSelectionBottomSheetFragment.show(getSupportFragmentManager(), flairSelectionBottomSheetFragment.getTag());
+            } else {
+                flairTextView.setBackgroundColor(resources.getColor(android.R.color.transparent));
+                flairTextView.setTextColor(primaryTextColor);
+                flairTextView.setText(getString(R.string.flair));
+                flair = null;
+            }
+        });
+
+        spoilerTextView.setOnClickListener(view -> {
+            if (!isSpoiler) {
+                spoilerTextView.setBackgroundColor(spoilerBackgroundColor);
+                spoilerTextView.setBorderColor(spoilerBackgroundColor);
+                spoilerTextView.setTextColor(spoilerTextColor);
+                isSpoiler = true;
+            } else {
+                spoilerTextView.setBackgroundColor(resources.getColor(android.R.color.transparent));
+                spoilerTextView.setTextColor(primaryTextColor);
+                isSpoiler = false;
+            }
+        });
+
+        nsfwTextView.setOnClickListener(view -> {
+            if (!isNSFW) {
+                nsfwTextView.setBackgroundColor(nsfwBackgroundColor);
+                nsfwTextView.setBorderColor(nsfwBackgroundColor);
+                nsfwTextView.setTextColor(nsfwTextColor);
+                isNSFW = true;
+            } else {
+                nsfwTextView.setBackgroundColor(resources.getColor(android.R.color.transparent));
+                nsfwTextView.setTextColor(primaryTextColor);
+                isNSFW = false;
+            }
+        });
+
+        receivePostReplyNotificationsLinearLayout.setOnClickListener(view -> {
+            receivePostReplyNotificationsSwitchMaterial.performClick();
+        });
     }
 
     @Override
     protected SharedPreferences getDefaultSharedPreferences() {
-        return null;
+        return mSharedPreferences;
     }
 
     @Override
     protected CustomThemeWrapper getCustomThemeWrapper() {
-        return null;
+        return mCustomThemeWrapper;
     }
 
     @Override
     protected void applyCustomTheme() {
+        coordinatorLayout.setBackgroundColor(mCustomThemeWrapper.getBackgroundColor());
+        applyAppBarLayoutAndToolbarTheme(appBarLayout, toolbar);
+        int secondaryTextColor = mCustomThemeWrapper.getSecondaryTextColor();
+        subredditNameTextView.setTextColor(secondaryTextColor);
+        rulesButton.setTextColor(mCustomThemeWrapper.getButtonTextColor());
+        rulesButton.setBackgroundColor(mCustomThemeWrapper.getColorPrimaryLightTheme());
+        primaryTextColor = mCustomThemeWrapper.getPrimaryTextColor();
+        receivePostReplyNotificationsTextView.setTextColor(primaryTextColor);
+        int dividerColor = mCustomThemeWrapper.getDividerColor();
+        divider1.setBackgroundColor(dividerColor);
+        divider2.setBackgroundColor(dividerColor);
+        divider3.setBackgroundColor(dividerColor);
+        divider4.setBackgroundColor(dividerColor);
+        flairBackgroundColor = mCustomThemeWrapper.getFlairBackgroundColor();
+        flairTextColor = mCustomThemeWrapper.getFlairTextColor();
+        spoilerBackgroundColor = mCustomThemeWrapper.getSpoilerBackgroundColor();
+        spoilerTextColor = mCustomThemeWrapper.getSpoilerTextColor();
+        nsfwBackgroundColor = mCustomThemeWrapper.getNsfwBackgroundColor();
+        nsfwTextColor = mCustomThemeWrapper.getNsfwTextColor();
+        flairTextView.setTextColor(primaryTextColor);
+        spoilerTextView.setTextColor(primaryTextColor);
+        nsfwTextView.setTextColor(primaryTextColor);
+        titleEditText.setTextColor(primaryTextColor);
+        titleEditText.setHintTextColor(secondaryTextColor);
+    }
+
+    private void displaySubredditIcon() {
+        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(iconGifImageView);
+        } else {
+            mGlide.load(R.drawable.subreddit_default_icon)
+                    .apply(RequestOptions.bitmapTransform(new RoundedCornersTransformation(72, 0)))
+                    .into(iconGifImageView);
+        }
+    }
+
+    private void loadSubredditIcon() {
+        LoadSubredditIcon.loadSubredditIcon(mExecutor, new Handler(), mRedditDataRoomDatabase, subredditName, mRetrofit, iconImageUrl -> {
+            iconUrl = iconImageUrl;
+            displaySubredditIcon();
+            loadSubredditIconSuccessful = true;
+        });
+    }
 
+    private void promptAlertDialog(int titleResId, int messageResId) {
+        new MaterialAlertDialogBuilder(this, R.style.MaterialAlertDialogTheme)
+                .setTitle(titleResId)
+                .setMessage(messageResId)
+                .setPositiveButton(R.string.yes, (dialogInterface, i)
+                        -> finish())
+                .setNegativeButton(R.string.no, null)
+                .show();
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        getMenuInflater().inflate(R.menu.post_image_activity, menu);
+        applyMenuItemTheme(menu);
+        mMemu = menu;
+        if (isPosting) {
+            mMemu.findItem(R.id.action_send_post_gallery_activity).setEnabled(false);
+            mMemu.findItem(R.id.action_send_post_gallery_activity).getIcon().setAlpha(130);
+        }
+        return true;
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(@NonNull MenuItem item) {
+        int itemId = item.getItemId();
+        if (itemId == android.R.id.home) {
+            if (isPosting) {
+                promptAlertDialog(R.string.exit_when_submit, R.string.exit_when_submit_post_detail);
+                return true;
+            } else {
+                if (!titleEditText.getText().toString().equals("") || imageUri != null) {
+                    promptAlertDialog(R.string.discard, R.string.discard_detail);
+                    return true;
+                }
+            }
+            finish();
+            return true;
+        } else if (itemId == R.id.action_send_post_image_activity) {
+            if (!subredditSelected) {
+                Snackbar.make(coordinatorLayout, R.string.select_a_subreddit, Snackbar.LENGTH_SHORT).show();
+                return true;
+            }
+
+            if (titleEditText.getText() == null || titleEditText.getText().toString().equals("")) {
+                Snackbar.make(coordinatorLayout, R.string.title_required, Snackbar.LENGTH_SHORT).show();
+                return true;
+            }
+
+            if (imageUri == null) {
+                Snackbar.make(coordinatorLayout, R.string.select_an_image, Snackbar.LENGTH_SHORT).show();
+                return true;
+            }
+
+            isPosting = true;
+
+            item.setEnabled(false);
+            item.getIcon().setAlpha(130);
+
+            mPostingSnackbar.show();
+
+            String subredditName;
+            if (subredditIsUser) {
+                subredditName = "u_" + subredditNameTextView.getText().toString();
+            } else {
+                subredditName = subredditNameTextView.getText().toString();
+            }
+
+            Intent intent = new Intent(this, SubmitPostService.class);
+            intent.setData(imageUri);
+            intent.putExtra(SubmitPostService.EXTRA_ACCESS_TOKEN, mAccessToken);
+            intent.putExtra(SubmitPostService.EXTRA_SUBREDDIT_NAME, subredditName);
+            intent.putExtra(SubmitPostService.EXTRA_TITLE, titleEditText.getText().toString());
+            intent.putExtra(SubmitPostService.EXTRA_FLAIR, flair);
+            intent.putExtra(SubmitPostService.EXTRA_IS_SPOILER, isSpoiler);
+            intent.putExtra(SubmitPostService.EXTRA_IS_NSFW, isNSFW);
+            intent.putExtra(SubmitPostService.EXTRA_RECEIVE_POST_REPLY_NOTIFICATIONS, receivePostReplyNotificationsSwitchMaterial.isChecked());
+            String mimeType = getContentResolver().getType(imageUri);
+            if (mimeType != null && mimeType.contains("gif")) {
+                intent.putExtra(SubmitPostService.EXTRA_POST_TYPE, SubmitPostService.EXTRA_POST_TYPE_VIDEO);
+            } else {
+                intent.putExtra(SubmitPostService.EXTRA_POST_TYPE, SubmitPostService.EXTRA_POST_TYPE_IMAGE);
+            }
+            intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
+
+            ContextCompat.startForegroundService(this, intent);
+
+            return true;
+        }
+
+        return false;
+    }
+
+    @Override
+    public void onBackPressed() {
+        if (isPosting) {
+            promptAlertDialog(R.string.exit_when_submit, R.string.exit_when_submit_post_detail);
+        } else {
+            if (!titleEditText.getText().toString().equals("") || imageUri != null) {
+                promptAlertDialog(R.string.discard, R.string.discard_detail);
+            } else {
+                finish();
+            }
+        }
+    }
+
+    @Override
+    protected void onSaveInstanceState(@NonNull Bundle outState) {
+        super.onSaveInstanceState(outState);
+        outState.putString(SUBREDDIT_NAME_STATE, subredditName);
+        outState.putString(SUBREDDIT_ICON_STATE, iconUrl);
+        outState.putBoolean(SUBREDDIT_SELECTED_STATE, subredditSelected);
+        outState.putBoolean(SUBREDDIT_IS_USER_STATE, subredditIsUser);
+        if (imageUri != null) {
+            outState.putString(IMAGE_URI_STATE, imageUri.toString());
+        }
+        outState.putBoolean(LOAD_SUBREDDIT_ICON_STATE, loadSubredditIconSuccessful);
+        outState.putBoolean(IS_POSTING_STATE, isPosting);
+        outState.putParcelable(FLAIR_STATE, flair);
+        outState.putBoolean(IS_SPOILER_STATE, isSpoiler);
+        outState.putBoolean(IS_NSFW_STATE, isNSFW);
+    }
+
+    @Override
+    protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
+        super.onActivityResult(requestCode, resultCode, data);
+        if (requestCode == SUBREDDIT_SELECTION_REQUEST_CODE) {
+            if (resultCode == RESULT_OK) {
+                subredditName = data.getExtras().getString(SubredditSelectionActivity.EXTRA_RETURN_SUBREDDIT_NAME);
+                iconUrl = data.getExtras().getString(SubredditSelectionActivity.EXTRA_RETURN_SUBREDDIT_ICON_URL);
+                subredditSelected = true;
+                subredditIsUser = data.getExtras().getBoolean(SubredditSelectionActivity.EXTRA_RETURN_SUBREDDIT_IS_USER);
+
+                subredditNameTextView.setTextColor(primaryTextColor);
+                subredditNameTextView.setText(subredditName);
+                displaySubredditIcon();
+
+                flairTextView.setVisibility(View.VISIBLE);
+                flairTextView.setBackgroundColor(resources.getColor(android.R.color.transparent));
+                flairTextView.setTextColor(primaryTextColor);
+                flairTextView.setText(getString(R.string.flair));
+                flair = null;
+            }
+        } else if (requestCode == PICK_IMAGE_REQUEST_CODE) {
+            if (resultCode == RESULT_OK) {
+                if (data == null) {
+                    Snackbar.make(coordinatorLayout, R.string.error_getting_image, Snackbar.LENGTH_SHORT).show();
+                    return;
+                }
+
+                imageUri = data.getData();
+                loadImage();
+            }
+        } else if (requestCode == CAPTURE_IMAGE_REQUEST_CODE) {
+            if (resultCode == RESULT_OK) {
+                loadImage();
+            }
+        }
+    }
+
+    @Override
+    protected void onDestroy() {
+        EventBus.getDefault().unregister(this);
+        super.onDestroy();
     }
 
     @Override
     public void flairSelected(Flair flair) {
+        this.flair = flair;
+        flairTextView.setText(flair.getText());
+        flairTextView.setBackgroundColor(flairBackgroundColor);
+        flairTextView.setBorderColor(flairBackgroundColor);
+        flairTextView.setTextColor(flairTextColor);
+    }
 
+    @Subscribe
+    public void onAccountSwitchEvent(SwitchAccountEvent event) {
+        finish();
     }
 }
\ No newline at end of file
diff --git a/app/src/main/java/ml/docilealligator/infinityforreddit/activities/PostImageActivity.java b/app/src/main/java/ml/docilealligator/infinityforreddit/activities/PostImageActivity.java
index 8fa24042..a1b0281c 100644
--- a/app/src/main/java/ml/docilealligator/infinityforreddit/activities/PostImageActivity.java
+++ b/app/src/main/java/ml/docilealligator/infinityforreddit/activities/PostImageActivity.java
@@ -470,69 +470,69 @@ public class PostImageActivity extends BaseActivity implements FlairBottomSheetF
 
     @Override
     public boolean onOptionsItemSelected(@NonNull MenuItem item) {
-        switch (item.getItemId()) {
-            case android.R.id.home:
-                if (isPosting) {
-                    promptAlertDialog(R.string.exit_when_submit, R.string.exit_when_submit_post_detail);
-                    return true;
-                } else {
-                    if (!titleEditText.getText().toString().equals("") || imageUri != null) {
-                        promptAlertDialog(R.string.discard, R.string.discard_detail);
-                        return true;
-                    }
-                }
-                finish();
+        int itemId = item.getItemId();
+        if (itemId == android.R.id.home) {
+            if (isPosting) {
+                promptAlertDialog(R.string.exit_when_submit, R.string.exit_when_submit_post_detail);
                 return true;
-            case R.id.action_send_post_image_activity:
-                if (!subredditSelected) {
-                    Snackbar.make(coordinatorLayout, R.string.select_a_subreddit, Snackbar.LENGTH_SHORT).show();
+            } else {
+                if (!titleEditText.getText().toString().equals("") || imageUri != null) {
+                    promptAlertDialog(R.string.discard, R.string.discard_detail);
                     return true;
                 }
+            }
+            finish();
+            return true;
+        } else if (itemId == R.id.action_send_post_image_activity) {
+            if (!subredditSelected) {
+                Snackbar.make(coordinatorLayout, R.string.select_a_subreddit, Snackbar.LENGTH_SHORT).show();
+                return true;
+            }
 
-                if (titleEditText.getText() == null || titleEditText.getText().toString().equals("")) {
-                    Snackbar.make(coordinatorLayout, R.string.title_required, Snackbar.LENGTH_SHORT).show();
-                    return true;
-                }
+            if (titleEditText.getText() == null || titleEditText.getText().toString().equals("")) {
+                Snackbar.make(coordinatorLayout, R.string.title_required, Snackbar.LENGTH_SHORT).show();
+                return true;
+            }
 
-                if (imageUri == null) {
-                    Snackbar.make(coordinatorLayout, R.string.select_an_image, Snackbar.LENGTH_SHORT).show();
-                    return true;
-                }
+            if (imageUri == null) {
+                Snackbar.make(coordinatorLayout, R.string.select_an_image, Snackbar.LENGTH_SHORT).show();
+                return true;
+            }
 
-                isPosting = true;
+            isPosting = true;
 
-                item.setEnabled(false);
-                item.getIcon().setAlpha(130);
+            item.setEnabled(false);
+            item.getIcon().setAlpha(130);
 
-                mPostingSnackbar.show();
+            mPostingSnackbar.show();
 
-                String subredditName;
-                if (subredditIsUser) {
-                    subredditName = "u_" + subredditNameTextView.getText().toString();
-                } else {
-                    subredditName = subredditNameTextView.getText().toString();
-                }
+            String subredditName;
+            if (subredditIsUser) {
+                subredditName = "u_" + subredditNameTextView.getText().toString();
+            } else {
+                subredditName = subredditNameTextView.getText().toString();
+            }
 
-                Intent intent = new Intent(this, SubmitPostService.class);
-                intent.setData(imageUri);
-                intent.putExtra(SubmitPostService.EXTRA_ACCESS_TOKEN, mAccessToken);
-                intent.putExtra(SubmitPostService.EXTRA_SUBREDDIT_NAME, subredditName);
-                intent.putExtra(SubmitPostService.EXTRA_TITLE, titleEditText.getText().toString());
-                intent.putExtra(SubmitPostService.EXTRA_FLAIR, flair);
-                intent.putExtra(SubmitPostService.EXTRA_IS_SPOILER, isSpoiler);
-                intent.putExtra(SubmitPostService.EXTRA_IS_NSFW, isNSFW);
-                intent.putExtra(SubmitPostService.EXTRA_RECEIVE_POST_REPLY_NOTIFICATIONS, receivePostReplyNotificationsSwitchMaterial.isChecked());
-                String mimeType = getContentResolver().getType(imageUri);
-                if (mimeType != null && mimeType.contains("gif")) {
-                    intent.putExtra(SubmitPostService.EXTRA_POST_TYPE, SubmitPostService.EXTRA_POST_TYPE_VIDEO);
-                } else {
-                    intent.putExtra(SubmitPostService.EXTRA_POST_TYPE, SubmitPostService.EXTRA_POST_TYPE_IMAGE);
-                }
-                intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
+            Intent intent = new Intent(this, SubmitPostService.class);
+            intent.setData(imageUri);
+            intent.putExtra(SubmitPostService.EXTRA_ACCESS_TOKEN, mAccessToken);
+            intent.putExtra(SubmitPostService.EXTRA_SUBREDDIT_NAME, subredditName);
+            intent.putExtra(SubmitPostService.EXTRA_TITLE, titleEditText.getText().toString());
+            intent.putExtra(SubmitPostService.EXTRA_FLAIR, flair);
+            intent.putExtra(SubmitPostService.EXTRA_IS_SPOILER, isSpoiler);
+            intent.putExtra(SubmitPostService.EXTRA_IS_NSFW, isNSFW);
+            intent.putExtra(SubmitPostService.EXTRA_RECEIVE_POST_REPLY_NOTIFICATIONS, receivePostReplyNotificationsSwitchMaterial.isChecked());
+            String mimeType = getContentResolver().getType(imageUri);
+            if (mimeType != null && mimeType.contains("gif")) {
+                intent.putExtra(SubmitPostService.EXTRA_POST_TYPE, SubmitPostService.EXTRA_POST_TYPE_VIDEO);
+            } else {
+                intent.putExtra(SubmitPostService.EXTRA_POST_TYPE, SubmitPostService.EXTRA_POST_TYPE_IMAGE);
+            }
+            intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
 
-                ContextCompat.startForegroundService(this, intent);
+            ContextCompat.startForegroundService(this, intent);
 
-                return true;
+            return true;
         }
 
         return false;
@@ -647,7 +647,7 @@ public class PostImageActivity extends BaseActivity implements FlairBottomSheetF
     }
 
     @Subscribe
-    public void onSubmitVideoOrGifPostEvent(SubmitVideoOrGifPostEvent submitVideoOrGifPostEvent) {
+    public void onSubmitGifPostEvent(SubmitVideoOrGifPostEvent submitVideoOrGifPostEvent) {
         isPosting = false;
         mPostingSnackbar.dismiss();
         mMemu.findItem(R.id.action_send_post_image_activity).setEnabled(true);