Added onRetryUploadForMediaClicked interface for GB

WordPress/src/main/java/org/wordpress/android/ui/posts/EditPostActivity.java

@@ -3231,6 +3231,27 @@ private void requestTemporaryPermissions(DragEvent dragEvent) {
         requestDragAndDropPermissions(dragEvent);
     }
 
+    @Override
+    public void onMediaRetryAllClicked(Set<String> failedMediaIds) {
+        UploadService.cancelFinalNotification(this, mPost);
+        UploadService.cancelFinalNotificationForMedia(this, mSite);
+
+        ArrayList<MediaModel> failedMediaList = new ArrayList<>();
+        for (String mediaId : failedMediaIds) {
+            failedMediaList.add(mMediaStore.getMediaWithLocalId(Integer.valueOf(mediaId)));
+        }
+
+        if (!failedMediaList.isEmpty()) {
+            for (MediaModel mediaModel : failedMediaList) {
+                mediaModel.setUploadState(MediaUploadState.QUEUED);
+                mDispatcher.dispatch(MediaActionBuilder.newUpdateMediaAction(mediaModel));
+            }
+            startUploadService(failedMediaList);
+        }
+
+        AnalyticsTracker.track(Stat.EDITOR_UPLOAD_MEDIA_RETRIED);
+    }
+
     @Override
     public boolean onMediaRetryClicked(final String mediaId) {
         if (TextUtils.isEmpty(mediaId)) {
@@ -3300,10 +3321,25 @@ public void onMediaUploadCancelClicked(String localMediaId) {
     @Override
     public void onMediaDeleted(String localMediaId) {
         if (!TextUtils.isEmpty(localMediaId)) {
-            mAztecBackspaceDeletedMediaItemIds.add(localMediaId);
-            UploadService.setDeletedMediaItemIds(mAztecBackspaceDeletedMediaItemIds);
-            // passing false here as we need to keep the media item in case the user wants to undo
-            cancelMediaUpload(StringUtils.stringToInt(localMediaId), false);
+            if (mShowAztecEditor) {
+                mAztecBackspaceDeletedMediaItemIds.add(localMediaId);
+                UploadService.setDeletedMediaItemIds(mAztecBackspaceDeletedMediaItemIds);
+                // passing false here as we need to keep the media item in case the user wants to undo
+                cancelMediaUpload(StringUtils.stringToInt(localMediaId), false);
+            } else if (mShowGutenbergEditor) {
+                MediaModel mediaModel = mMediaStore.getMediaWithLocalId(StringUtils.stringToInt(localMediaId));
+                if (mediaModel == null) {
+                    return;
+                }
+
+                // also make sure it's not being uploaded anywhere else (maybe on some other Post,
+                // simultaneously)
+                if (mediaModel.getUploadState() != null
+                    && MediaUtils.isLocalFile(mediaModel.getUploadState().toLowerCase(Locale.ROOT))
+                    && !UploadService.isPendingOrInProgressMediaUpload(mediaModel)) {
+                    mDispatcher.dispatch(MediaActionBuilder.newRemoveMediaAction(mediaModel));
+                }
+            }
         }
     }
 
@@ -3482,6 +3518,18 @@ public void onJavaScriptAlert(String url, String message) {
                 }
             });
         }
+
+        // probably here is best for Gutenberg to start interacting with
+        if (mShowGutenbergEditor && mEditorFragment instanceof GutenbergEditorFragment) {
+            List<MediaModel> failedMedia = mMediaStore.getMediaForPostWithState(mPost, MediaUploadState.FAILED);
+            if (failedMedia != null && !failedMedia.isEmpty()) {
+                HashSet<Integer> mediaIds = new HashSet<>();
+                for (MediaModel media : failedMedia) {
+                    mediaIds.add(media.getId());
+                }
+                ((GutenbergEditorFragment) mEditorFragment).resetUploadingMediaToFailed(mediaIds);
+            }
+        }
     }
 
     @Override

WordPress/src/main/java/org/wordpress/android/ui/uploads/UploadService.java

@@ -244,12 +244,16 @@ private void unpackPostIntent(@NonNull Intent intent) {
             }
 
             if (intent.getBooleanExtra(KEY_SHOULD_RETRY, false)) {
-                if (AppPrefs.isAztecEditorEnabled()) {
+                if (AppPrefs.isAztecEditorEnabled() || AppPrefs.isGutenbergEditorEnabled()) {
                     if (!NetworkUtils.isNetworkAvailable(this)) {
                         rebuildNotificationError(post, getString(R.string.no_network_message));
                         return;
                     }
-                    aztecRetryUpload(post);
+                    boolean postHasGutenbergBlocks = PostUtils.contentContainsGutenbergBlocks(post.getContent());
+                    boolean processWithAztec =
+                            AppPrefs.isAztecEditorEnabled() && !AppPrefs.isGutenbergEditorEnabled()
+                            && !postHasGutenbergBlocks;
+                    retryUpload(post, processWithAztec);
                 } else {
                     ToastUtils.showToast(this, R.string.retry_needs_aztec);
                 }
@@ -706,7 +710,7 @@ private void rebuildNotificationError(PostModel post, String errorMessage) {
                                                            errorMessage, 0);
     }
 
-    private void registerFailedMediaForThisPost(PostModel post) {
+    private void aztecRegisterFailedMediaForThisPost(PostModel post) {
         // there could be failed media in the post, that has not been registered in the UploadStore because
         // the media was being uploaded separately (i.e. the user included media, started uploading within
         // the editor, and such media failed _before_ exiting the eidtor, thus the registration never happened.
@@ -740,10 +744,12 @@ private void registerFailedMediaForThisPost(PostModel post) {
         }
     }
 
-    private void aztecRetryUpload(PostModel post) {
+    private void retryUpload(PostModel post, boolean processWithAztec) {
         AnalyticsTracker.track(AnalyticsTracker.Stat.NOTIFICATION_UPLOAD_POST_ERROR_RETRY);
 
-        registerFailedMediaForThisPost(post);
+        if (processWithAztec) {
+            aztecRegisterFailedMediaForThisPost(post);
+        }
 
         Set<MediaModel> failedMedia = mUploadStore.getFailedMediaForPost(post);
         ArrayList<MediaModel> mediaToRetry = new ArrayList<>(failedMedia);
@@ -755,11 +761,13 @@ private void aztecRetryUpload(PostModel post) {
                 mDispatcher.dispatch(MediaActionBuilder.newUpdateMediaAction(media));
             }
 
-            // do the same within the Post content itself
-            String postContentWithRestartedUploads =
-                    AztecEditorFragment.restartFailedMediaToUploading(this, post.getContent());
-            post.setContent(postContentWithRestartedUploads);
-            mDispatcher.dispatch(PostActionBuilder.newUpdatePostAction(post));
+            if (processWithAztec) {
+                // do the same within the Post content itself
+                String postContentWithRestartedUploads =
+                        AztecEditorFragment.restartFailedMediaToUploading(this, post.getContent());
+                post.setContent(postContentWithRestartedUploads);
+                mDispatcher.dispatch(PostActionBuilder.newUpdatePostAction(post));
+            }
 
             // no retry uploading the media items
             for (MediaModel media : mediaToRetry) {

libs/editor/WordPressEditor/src/androidTest/java/org.wordpress.android.editor/MockEditorActivity.java

@@ -14,6 +14,7 @@
 import org.wordpress.android.util.helpers.MediaFile;
 
 import java.util.ArrayList;
+import java.util.Set;
 
 public class MockEditorActivity extends AppCompatActivity implements EditorFragmentListener,
         EditorDragAndDropListener {
@@ -57,6 +58,10 @@ public boolean onMediaRetryClicked(String mediaId) {
         return true;
     }
 
+    @Override
+    public void onMediaRetryAllClicked(Set<String> mediaIdSet) {
+    }
+
     @Override
     public void onMediaUploadCancelClicked(String mediaId) {
     }

libs/editor/WordPressEditor/src/main/java/org/wordpress/android/editor/EditorFragmentAbstract.java

@@ -17,6 +17,7 @@
 
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.Set;
 
 public abstract class EditorFragmentAbstract extends Fragment {
     public abstract void setTitle(CharSequence text);
@@ -182,6 +183,7 @@ public interface EditorFragmentListener {
         void onAddPhotoClicked();
         void onCapturePhotoClicked();
         boolean onMediaRetryClicked(String mediaId);
+        void onMediaRetryAllClicked(Set<String> mediaIdSet);
         void onMediaUploadCancelClicked(String mediaId);
         void onMediaDeleted(String mediaId);
         void onUndoMediaCheck(String undoedContent);

libs/editor/WordPressEditor/src/main/java/org/wordpress/android/editor/GutenbergEditorFragment.java

@@ -3,14 +3,18 @@
 import android.app.Activity;
 import android.arch.lifecycle.LiveData;
 import android.content.Context;
+import android.content.DialogInterface;
+import android.content.DialogInterface.OnClickListener;
 import android.content.res.Configuration;
 import android.os.Bundle;
 import android.os.Handler;
 import android.support.annotation.NonNull;
 import android.support.v7.app.ActionBar;
+import android.support.v7.app.AlertDialog;
 import android.support.v7.app.AppCompatActivity;
 import android.text.Editable;
 import android.text.Spanned;
+import android.view.ContextThemeWrapper;
 import android.view.LayoutInflater;
 import android.view.Menu;
 import android.view.MenuInflater;
@@ -124,10 +128,19 @@ public void onUploadMediaButtonClicked() {
                     public void onCapturePhotoButtonClicked() {
                         checkAndRequestCameraAndStoragePermissions();
                     }
+
+                    @Override public void onRetryUploadForMediaClicked(int mediaId) {
+                        showRetryMediaUploadDialog(mediaId);
+                    }
+
+                    @Override public void onCancelUploadForMediaClicked(int mediaId) {
+                        showCancelMediaUploadDialog(mediaId);
+                    }
                 },
                 new OnReattachQueryListener() {
                     @Override
                     public void onQueryCurrentProgressForUploadingMedia() {
+                        updateFailedMediaState();
                         updateMediaProgress();
                     }
                 },
@@ -170,20 +183,108 @@ public void onRequestPermissionsResult(int requestCode, @NonNull String[] permis
         }
     }
 
+    public void resetUploadingMediaToFailed(Set<Integer> failedMediaIds) {
+        // get all media failed for this post, and represent it on tje UI
+        if (failedMediaIds != null && !failedMediaIds.isEmpty()) {
+            for (Integer mediaId : failedMediaIds) {
+                // and keep track of failed ids around
+                mFailedMediaIds.add(String.valueOf(mediaId));
+            }
+        }
+    }
+
+    private void updateFailedMediaState() {
+        for (String mediaId : mFailedMediaIds) {
+            mWPAndroidGlueCode.mediaFileUploadFailed(Integer.valueOf(mediaId));
+        }
+    }
+
     private void updateMediaProgress() {
         for (String mediaId : mUploadingMediaProgressMax.keySet()) {
             mWPAndroidGlueCode.mediaFileUploadProgress(Integer.valueOf(mediaId),
                     mUploadingMediaProgressMax.get(mediaId));
         }
     }
-    
+
     private void checkAndRequestCameraAndStoragePermissions() {
         if (PermissionUtils.checkAndRequestCameraAndStoragePermissions(this,
                 CAPTURE_PHOTO_PERMISSION_REQUEST_CODE)) {
             mEditorFragmentListener.onCapturePhotoClicked();
         }
     }
 
+    private void showCancelMediaUploadDialog(final int localMediaId) {
+        // Display 'cancel upload' dialog
+        AlertDialog.Builder builder = new AlertDialog.Builder(
+                new ContextThemeWrapper(getActivity(), R.style.Calypso_Dialog_Alert));
+        builder.setTitle(getString(R.string.stop_upload_dialog_title));
+        builder.setPositiveButton(R.string.stop_upload_dialog_button_yes,
+                new DialogInterface.OnClickListener() {
+                    public void onClick(DialogInterface dialog, int id) {
+                        if (mUploadingMediaProgressMax.containsKey(String.valueOf(localMediaId))) {
+                            mEditorFragmentListener.onMediaUploadCancelClicked(String.valueOf(localMediaId));
+                            // remove from editor
+                            mEditorFragmentListener.onMediaDeleted(String.valueOf(localMediaId));
+                            mWPAndroidGlueCode.clearMediaFileURL(localMediaId);
+                            mUploadingMediaProgressMax.remove(localMediaId);
+                        } else {
+                            ToastUtils.showToast(getActivity(), R.string.upload_finished_toast).show();
+                        }
+                        dialog.dismiss();
+                    }
+                });
+
+        builder.setNegativeButton(R.string.stop_upload_dialog_button_no, new DialogInterface.OnClickListener() {
+            public void onClick(DialogInterface dialog, int id) {
+                dialog.dismiss();
+            }
+        });
+
+        AlertDialog dialog = builder.create();
+        dialog.show();
+    }
+
+    private void showRetryMediaUploadDialog(final int mediaId) {
+        // Display 'retry upload' dialog
+        AlertDialog.Builder builder = new AlertDialog.Builder(
+                new ContextThemeWrapper(getActivity(), R.style.Calypso_Dialog_Alert));
+        builder.setTitle(getString(R.string.retry_failed_upload_title));
+        builder.setPositiveButton(R.string.retry_failed_upload_yes,
+                new DialogInterface.OnClickListener() {
+                    public void onClick(DialogInterface dialog, int id) {
+                        dialog.dismiss();
+                        boolean successfullyRetried = true;
+                        if (mFailedMediaIds.contains(String.valueOf(mediaId))) {
+                            successfullyRetried = mEditorFragmentListener.onMediaRetryClicked(String.valueOf(mediaId));
+                        }
+                        if (successfullyRetried) {
+                            mFailedMediaIds.remove(String.valueOf(mediaId));
+                            mUploadingMediaProgressMax.put(String.valueOf(mediaId), 0f);
+                            mWPAndroidGlueCode.mediaFileUploadProgress(mediaId,
+                                    mUploadingMediaProgressMax.get(String.valueOf(mediaId)));
+                        }
+                    }
+                });
+
+        builder.setNeutralButton(R.string.retry_failed_upload_retry_all, new OnClickListener() {
+            @Override public void onClick(DialogInterface dialog, int which) {
+                dialog.dismiss();
+                mEditorFragmentListener.onMediaRetryAllClicked(mFailedMediaIds);
+            }
+        });
+
+        builder.setNegativeButton(R.string.retry_failed_upload_remove, new DialogInterface.OnClickListener() {
+            public void onClick(DialogInterface dialog, int id) {
+                dialog.dismiss();
+                mEditorFragmentListener.onMediaDeleted(String.valueOf(mediaId));
+                mWPAndroidGlueCode.clearMediaFileURL(mediaId);
+            }
+        });
+
+        AlertDialog dialog = builder.create();
+        dialog.show();
+    }
+
     @Override
     public void onPause() {
         super.onPause();

libs/editor/WordPressEditor/src/main/res/values/strings.xml

@@ -128,4 +128,10 @@
     <string name="stop_upload_dialog_button_yes">Yes</string>
     <string name="stop_upload_dialog_button_no">No</string>
 
+    <string name="retry_failed_upload_title">Retry uploading?</string>
+    <string name="retry_failed_upload_yes">Retry</string>
+    <string name="retry_failed_upload_remove">Remove</string>
+    <string name="retry_failed_upload_retry_all">Retry all</string>
+
+
 </resources>