Fix for sorting on a separate thread

2 files changed, 62 insertions, 18 deletions

diff --git a/app/src/main/java/org/rssin/android/FeedItemsListFragment.java b/app/src/main/java/org/rssin/android/FeedItemsListFragment.java
index 27c4eb5..22ba4d4 100644
--- a/app/src/main/java/org/rssin/android/FeedItemsListFragment.java
+++ b/app/src/main/java/org/rssin/android/FeedItemsListFragment.java
@@ -100,6 +100,7 @@ public class FeedItemsListFragment extends Fragment {
             loaderAndSorter.getFilteredFeedItems(
                     DefaultStorageProvider.getInstance(context),
                     VolleyFetcher.getInstance(context),
+                    getActivity(),
                     new RealtimeListener<List<SortedFeedItemContainer>, Object>() {
                         @Override
                         public void finish() {
diff --git a/app/src/main/java/org/rssin/rssin/FeedLoaderAndSorter.java b/app/src/main/java/org/rssin/rssin/FeedLoaderAndSorter.java
index 9c4ad2f..279f996 100755
--- a/app/src/main/java/org/rssin/rssin/FeedLoaderAndSorter.java
+++ b/app/src/main/java/org/rssin/rssin/FeedLoaderAndSorter.java
@@ -18,6 +18,7 @@
  */

 package org.rssin.rssin;

 

+import android.app.Activity;

 import android.util.Log;

 

 import org.rssin.rss.FeedSorterProvider;

@@ -56,6 +57,7 @@ public class FeedLoaderAndSorter {
     public void getFilteredFeedItems(

             StorageProvider storageProvider,

             Fetcher fetcher,

+            Activity runOn,

             final RealtimeListener<List<SortedFeedItemContainer>, Object> listener) {

         final List<SortedFeedItemContainer> resultingItems = new ArrayList<>();

         final Counter counter = new Counter(feeds.size());

@@ -68,7 +70,8 @@ public class FeedLoaderAndSorter {
                     listener,

                     resultingItems,

                     counter,

-                    sorter

+                    sorter,

+                    runOn

             );

             Thread thread = new Thread(loader);

             thread.start();

@@ -83,6 +86,7 @@ public class FeedLoaderAndSorter {
         final private List<SortedFeedItemContainer> resultingItems;

         final private Counter counter;

         final private FeedSorter feedSorter;

+        final private Activity runOn;

 

         public Loader(

                 Feed feed,

@@ -90,13 +94,15 @@ public class FeedLoaderAndSorter {
                 RealtimeListener<List<SortedFeedItemContainer>,Object> listener,

                 List<SortedFeedItemContainer> resultingItems,

                 Counter counter,

-                FeedSorter feedSorter) {

+                FeedSorter feedSorter,

+                Activity runOn) {

             this.feed = feed;

             this.fetcher = fetcher;

             this.listener = listener;

             this.resultingItems = resultingItems;

             this.counter = counter;

             this.feedSorter = feedSorter;

+            this.runOn = runOn;

         }

 

         @Override

@@ -106,22 +112,9 @@ public class FeedLoaderAndSorter {
                 @Override

                 public void onReceive(Object data) {

                     List<FeedItem> feedItems = loader.getFeed().getPosts();

-                    synchronized (resultingItems) {

-                        for (FeedItem item : feedItems) {

-                            if(item != null) {

-                                resultingItems.add(new SortedFeedItemContainer(item));

-                            }

-                        }

-                        feedSorter.sortItems(resultingItems);

-                    }

-

-                    synchronized (counter) {

-                        counter.decr();

-                        listener.onReceive(resultingItems);

-                        if (counter.isZero()) {

-                            ((RealtimeListener) listener).finish();

-                        }

-                    }

+                    Sorter sorter = new Sorter(resultingItems, feedItems, counter, feedSorter, listener, runOn);

+                    Thread thread = new Thread(sorter);

+                    thread.start();

                 }

 

                 @Override

@@ -130,6 +123,56 @@ public class FeedLoaderAndSorter {
                 }

             });

         }

+

+        private static class Sorter implements Runnable {

+

+            private final List<SortedFeedItemContainer> resultingItems;

+            private final List<FeedItem> newItems;

+            private final Counter counter;

+            private final FeedSorter sorter;

+            private final RealtimeListener listener;

+            private final Activity runOn;

+

+            public Sorter(List<SortedFeedItemContainer> resultingItems,

+                          List<FeedItem> newItems,

+                          Counter counter,

+                          FeedSorter sorter,

+                          RealtimeListener listener,

+                          Activity runOn) {

+                this.resultingItems = resultingItems;

+                this.newItems = newItems;

+                this.counter = counter;

+                this.sorter = sorter;

+                this.listener = listener;

+                this.runOn = runOn;

+            }

+

+            @Override

+            public void run() {

+                synchronized (resultingItems) {

+                    for (FeedItem item : newItems) {

+                        if(item != null) {

+                            resultingItems.add(new SortedFeedItemContainer(item));

+                        }

+                    }

+                    sorter.sortItems(resultingItems);

+                }

+

+                synchronized (counter) {

+                    counter.decr();

+

+                    runOn.runOnUiThread(new Runnable() {

+                        @Override

+                        public void run() {

+                            listener.onReceive(resultingItems);

+                            if (counter.isZero()) {

+                                listener.finish();

+                            }

+                        }

+                    });

+                }

+            }

+        }

     }

 

     private static class Counter {