Just a commit while restucturing with API

2018-05-03 22:41:29 +02:00
parent f2e959df87
commit 58a79fc2c4
13 changed files with 477 additions and 125 deletions
--- a/app/src/main/java/de/sebse/fuplanner/tools/AsyncQueue.java
+++ b/app/src/main/java/de/sebse/fuplanner/tools/AsyncQueue.java
@@ -0,0 +1,107 @@
+package de.sebse.fuplanner.tools;
+
+import android.support.annotation.NonNull;
+
+import java.util.LinkedList;
+
+import de.sebse.fuplanner.tools.network.NetworkCallback;
+import de.sebse.fuplanner.tools.network.NetworkError;
+import de.sebse.fuplanner.tools.network.NetworkErrorCallback;
+
+public class AsyncQueue {
+    private LinkedList<AsyncQueueCallback> mQueue = new LinkedList<>();
+    private boolean mRunning = false;
+
+    public void add(AsyncQueueCallback callback) {
+        if (mRunning)
+            mQueue.addLast(callback);
+        else {
+            mRunning = true;
+            callback.run();
+        }
+    }
+
+    public void next() {
+        AsyncQueueCallback callback = mQueue.pollFirst();
+        if (callback == null)
+            mRunning = false;
+        else
+            callback.run();
+    }
+
+    public interface AsyncQueueCallback {
+        void run();
+    }
+
+    public NetworkErrorCallback check(final NetworkErrorCallback value) {
+        return new NetworkErrorCallback() {
+            @Override
+            public void onError(NetworkError error) {
+                value.onError(error);
+                next();
+            }
+        };
+    }
+
+    public <T> NetworkCallback<T> check(final NetworkCallback<T> value) {
+        return new NetworkCallback<T>() {
+            @Override
+            public void onResponse(@NonNull T success) {
+                value.onResponse(success);
+                next();
+            }
+        };
+    }
+}
+
+/*public class AsyncQueue<T, U> {
+    private ArrayList<T> successes = new ArrayList<>();
+    private ArrayList<U> errors = new ArrayList<>();
+    private boolean isRequesting = false;
+
+    public void add(T successFunc, U errorFunc) {
+        this.successes.add(successFunc);
+        this.errors.add(errorFunc);
+    }
+
+    public void add(T successFunc, U errorFunc, AsyncQueueCallback request) {
+        this.add(successFunc, errorFunc);
+        request(request);
+    }
+
+    public void forEachSuccess(AsyncQueueCallbackValue<T> forEach) {
+        isRequesting = false;
+        for (T success: this.successes) {
+            forEach.run(success);
+        }
+        this.clear();
+    }
+
+    public void forEachError(AsyncQueueCallbackValue<U> forEach) {
+        isRequesting = false;
+        for (U error: this.errors) {
+            forEach.run(error);
+        }
+        this.clear();
+    }
+
+    public void clear() {
+        this.successes.clear();
+        this.errors.clear();
+    }
+
+    public void request(AsyncQueueCallback request) {
+        if (!this.isRequesting) {
+            this.isRequesting = true;
+            request.run();
+        }
+    }
+
+    public interface AsyncQueueCallbackValue<T> {
+        public void run(T value);
+    }
+
+    public interface AsyncQueueCallback {
+        public void run();
+    }
+}*/