From 8819326b7223896bf9173e110b087ac4fecb07f9 Mon Sep 17 00:00:00 2001
From: Camil Staps
Date: Sun, 14 Jun 2015 11:26:22 +0200
Subject: Fix for sorting on a separate thread

---
 .../org/rssin/android/FeedItemsListFragment.java   |  1 +
 .../java/org/rssin/rssin/FeedLoaderAndSorter.java  | 79 +++++++++++++++++-----
 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 {
-- 
cgit v1.2.3