Add api utils

app/src/main/java/com/github/gotify/api/Api.java

@@ -0,0 +1,77 @@
+package com.github.gotify.api;
+
+import android.app.Activity;
+
+import com.github.gotify.client.ApiCallback;
+import com.github.gotify.client.ApiException;
+import com.github.gotify.log.Log;
+
+import java.util.List;
+import java.util.Map;
+
+public class Api {
+    public static <T> CallExecutor<T> withLogging(ApiCall<T> call) {
+        return new CallExecutor<T>(call);
+    }
+
+    private static <T> Callback<T> loggingCallback() {
+        return Callback.call(
+                (data) -> {},
+                (exception) ->
+                        Log.e("Error while api call: " + exception.getResponseBody(), exception));
+    }
+
+    public interface ApiCall<T> {
+        void call(ApiCallback<T> callback) throws ApiException;
+    }
+
+    public static class CallExecutor<T> {
+        private ApiCall<T> call;
+
+        private CallExecutor(ApiCall<T> call) {
+            this.call = call;
+        }
+
+        public void handle(Callback<T> callback) {
+            Callback<T> merged = Callback.merge(callback, loggingCallback());
+            try {
+                call.call(fromCallback(merged));
+            } catch (ApiException e) {
+                merged.onError(e);
+            }
+        }
+
+        public void handleInUIThread(
+                Activity activity,
+                Callback.SuccessCallback<T> onSuccess,
+                Callback.ErrorCallback onError) {
+            handle(Callback.runInUIThread(activity, Callback.call(onSuccess, onError)));
+        }
+
+        public void handle(Callback.SuccessCallback<T> onSuccess, Callback.ErrorCallback onError) {
+            handle(Callback.call(onSuccess, onError));
+        }
+    }
+
+    private static <T> ApiCallback<T> fromCallback(Callback<T> callback) {
+        return new ApiCallback<T>() {
+            @Override
+            public void onFailure(
+                    ApiException e, int statusCode, Map<String, List<String>> responseHeaders) {
+                callback.onError(e);
+            }
+
+            @Override
+            public void onSuccess(
+                    T result, int statusCode, Map<String, List<String>> responseHeaders) {
+                callback.onSuccess(result);
+            }
+
+            @Override
+            public void onUploadProgress(long bytesWritten, long contentLength, boolean done) {}
+
+            @Override
+            public void onDownloadProgress(long bytesRead, long contentLength, boolean done) {}
+        };
+    }
+}

app/src/main/java/com/github/gotify/api/Callback.java

@@ -0,0 +1,57 @@
+package com.github.gotify.api;
+
+import android.app.Activity;
+
+import com.github.gotify.client.ApiException;
+
+public class Callback<T> {
+    private final SuccessCallback<T> onSuccess;
+    private final ErrorCallback onError;
+
+    private Callback(SuccessCallback<T> onSuccess, ErrorCallback onError) {
+        this.onSuccess = onSuccess;
+        this.onError = onError;
+    }
+
+    void onSuccess(T data) {
+        this.onSuccess.onSuccess(data);
+    }
+
+    void onError(ApiException exception) {
+        this.onError.onError(exception);
+    }
+
+    public static <T> Callback<T> call(SuccessCallback<T> onSuccess, ErrorCallback onError) {
+        return new Callback<>(onSuccess, onError);
+    }
+
+    public static <T> Callback<T> merge(Callback<T> left, Callback<T> right) {
+        return new Callback<>(
+                (data) -> {
+                    left.onSuccess(data);
+                    right.onSuccess(data);
+                },
+                (error) -> {
+                    left.onError(error);
+                    right.onError(error);
+                });
+    }
+
+    public static <T> Callback<T> runInUIThread(Activity context, Callback<T> callback) {
+        return call(
+                (data) -> {
+                    context.runOnUiThread(() -> callback.onSuccess(data));
+                },
+                (e) -> {
+                    context.runOnUiThread(() -> callback.onError(e));
+                });
+    }
+
+    public interface SuccessCallback<T> {
+        void onSuccess(T data);
+    }
+
+    public interface ErrorCallback {
+        void onError(ApiException e);
+    }
+}

app/src/main/java/com/github/gotify/api/ClientFactory.java

@@ -0,0 +1,40 @@
+package com.github.gotify.api;
+
+import com.github.gotify.Settings;
+import com.github.gotify.client.ApiClient;
+import com.github.gotify.client.api.UserApi;
+import com.github.gotify.client.api.VersionApi;
+import com.github.gotify.client.auth.ApiKeyAuth;
+import com.github.gotify.client.auth.HttpBasicAuth;
+
+public class ClientFactory {
+    public static ApiClient unauthorized(String baseUrl) {
+        ApiClient client = new ApiClient();
+        client.setBasePath(baseUrl);
+        return client;
+    }
+
+    public static ApiClient basicAuth(String baseUrl, String username, String password) {
+        ApiClient client = unauthorized(baseUrl);
+        HttpBasicAuth auth = (HttpBasicAuth) client.getAuthentication("basicAuth");
+        auth.setUsername(username);
+        auth.setPassword(password);
+
+        return client;
+    }
+
+    public static ApiClient clientToken(String baseUrl, String token) {
+        ApiClient client = unauthorized(baseUrl);
+        ApiKeyAuth tokenAuth = (ApiKeyAuth) client.getAuthentication("clientTokenHeader");
+        tokenAuth.setApiKey(token);
+        return client;
+    }
+
+    public static VersionApi versionApi(String baseUrl) {
+        return new VersionApi(unauthorized(baseUrl));
+    }
+
+    public static UserApi userApiWithToken(Settings settings) {
+        return new UserApi(clientToken(settings.url(), settings.token()));
+    }
+}