add default looper and possibility chain promises

Author: codlab

promise/src/main/java/eu/codlab/simplepromise/AbstractPromise.java

@@ -1,13 +1,33 @@
 package eu.codlab.simplepromise;
 
-import eu.codlab.simplepromise.solve.PromiseExec;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
 
-/**
- * Created by kevinleperf on 15/04/2018.
- */
+import eu.codlab.simplepromise.solve.PromiseExec;
+import eu.codlab.simplepromise.solve.Solver;
 
 public abstract class AbstractPromise<TYPE_EXECUTE> {
 
     protected abstract <TYPE_RESULT> PromiseInOut<TYPE_EXECUTE, TYPE_RESULT>
     then(PromiseExec<TYPE_EXECUTE, TYPE_RESULT> to_resolve);
+
+    /**
+     * Let possible to resolve a promise in chain
+     *
+     * This notation will discard the result from the previous
+     *
+     * @param to_resolve the promise to make the new chain
+     * @param <TYPE_RESULT> the type of result from the promise
+     *
+     * @return an object resolvable
+     */
+    protected <TYPE_RESULT> PromiseInOut<TYPE_EXECUTE, TYPE_RESULT>
+    then(final Promise<TYPE_RESULT> to_resolve) {
+        return new PromiseInOut<>(new PromiseExec<TYPE_EXECUTE, TYPE_RESULT>() {
+            @Override
+            public void onCall(@Nullable TYPE_EXECUTE result, @NonNull Solver<TYPE_RESULT> solver) {
+                solver.resolve(to_resolve);
+            }
+        });
+    }
 }

promise/src/main/java/eu/codlab/simplepromise/Promise.java

@@ -1,13 +1,16 @@
 package eu.codlab.simplepromise;
 
 import android.os.Handler;
+import android.os.Looper;
 import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
 
 import java.util.List;
 
 import eu.codlab.simplepromise.solve.ErrorPromise;
 import eu.codlab.simplepromise.solve.PromiseExec;
 import eu.codlab.simplepromise.solve.PromiseSolver;
+import eu.codlab.simplepromise.solve.Solver;
 
 public class Promise<TYPE> extends AbstractPromise<TYPE> {
 
@@ -16,7 +19,7 @@ public static <T> Promise<List<T>> all(AbstractPromise<T>...promises) {
     }
 
     @NonNull
-    private static Handler sHandler = new Handler();
+    private static Handler sHandler = new Handler(Looper.getMainLooper());
 
     public static void setHandler(@NonNull Handler handler) {
         sHandler = handler;
@@ -45,6 +48,16 @@ public <TYPE_RESULT> PromiseInOut<TYPE, TYPE_RESULT> then(PromiseExec<TYPE, TYPE
         return then(new PromiseInOut<>(to_resolve));
     }
 
+    public <TYPE_RESULT> PromiseInOut<TYPE, TYPE_RESULT> then(final TYPE_RESULT resolved) {
+        return then(new PromiseExec<TYPE, TYPE_RESULT>() {
+            @Override
+            public void onCall(@Nullable TYPE result, @NonNull Solver<TYPE_RESULT> solver) {
+                solver.resolve(resolved);
+            }
+        });
+    }
+
+
     public <TYPE_RESULT> void error(ErrorPromise to_error) {
         PromiseInOut<TYPE, TYPE_RESULT> promise_inout = new PromiseInOut<>(to_error);
         promise_inout.setParent(mPromiseInOut);