add readme and license, rename the server module

server/src/main/kotlin/eu/kanade/tachiyomi/network/NetworkHelper.kt

@@ -0,0 +1,70 @@
+package eu.kanade.tachiyomi.network
+
+//import android.content.Context
+//import eu.kanade.tachiyomi.BuildConfig
+//import eu.kanade.tachiyomi.data.preference.PreferencesHelper
+import okhttp3.Cache
+//import okhttp3.HttpUrl.Companion.toHttpUrl
+import okhttp3.OkHttpClient
+//import okhttp3.dnsoverhttps.DnsOverHttps
+//import okhttp3.logging.HttpLoggingInterceptor
+//import uy.kohesive.injekt.injectLazy
+import java.io.File
+import java.net.InetAddress
+import java.util.concurrent.TimeUnit
+
+class NetworkHelper() {
+
+//    private val preferences: PreferencesHelper by injectLazy()
+
+//    private val cacheDir = File(context.cacheDir, "network_cache")
+
+    private val cacheSize = 5L * 1024 * 1024 // 5 MiB
+
+//    val cookieManager = AndroidCookieJar()
+
+    val client by lazy {
+        val builder = OkHttpClient.Builder()
+//            .cookieJar(cookieManager)
+//            .cache(Cache(cacheDir, cacheSize))
+            .connectTimeout(30, TimeUnit.SECONDS)
+            .readTimeout(30, TimeUnit.SECONDS)
+//            .addInterceptor(UserAgentInterceptor())
+
+//        if (BuildConfig.DEBUG) {
+//            val httpLoggingInterceptor = HttpLoggingInterceptor().apply {
+//                level = HttpLoggingInterceptor.Level.HEADERS
+//            }
+//            builder.addInterceptor(httpLoggingInterceptor)
+//        }
+
+//        if (preferences.enableDoh()) {
+//            builder.dns(
+//                DnsOverHttps.Builder().client(builder.build())
+//                    .url("https://cloudflare-dns.com/dns-query".toHttpUrl())
+//                    .bootstrapDnsHosts(
+//                        listOf(
+//                            InetAddress.getByName("162.159.36.1"),
+//                            InetAddress.getByName("162.159.46.1"),
+//                            InetAddress.getByName("1.1.1.1"),
+//                            InetAddress.getByName("1.0.0.1"),
+//                            InetAddress.getByName("162.159.132.53"),
+//                            InetAddress.getByName("2606:4700:4700::1111"),
+//                            InetAddress.getByName("2606:4700:4700::1001"),
+//                            InetAddress.getByName("2606:4700:4700::0064"),
+//                            InetAddress.getByName("2606:4700:4700::6400")
+//                        )
+//                    )
+//                    .build()
+//            )
+//        }
+
+        builder.build()
+    }
+
+//    val cloudflareClient by lazy {
+//        client.newBuilder()
+//            .addInterceptor(CloudflareInterceptor(context))
+//            .build()
+//    }
+}

server/src/main/kotlin/eu/kanade/tachiyomi/network/OkHttpExtensions.kt

@@ -0,0 +1,121 @@
+package eu.kanade.tachiyomi.network
+
+//import kotlinx.coroutines.suspendCancellableCoroutine
+import okhttp3.Call
+import okhttp3.Callback
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.Response
+import rx.Observable
+import rx.Producer
+import rx.Subscription
+import java.io.IOException
+import java.util.concurrent.atomic.AtomicBoolean
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+
+fun Call.asObservable(): Observable<Response> {
+    return Observable.unsafeCreate { subscriber ->
+        // Since Call is a one-shot type, clone it for each new subscriber.
+        val call = clone()
+
+        // Wrap the call in a helper which handles both unsubscription and backpressure.
+        val requestArbiter = object : AtomicBoolean(), Producer, Subscription {
+            override fun request(n: Long) {
+                if (n == 0L || !compareAndSet(false, true)) return
+
+                try {
+                    val response = call.execute()
+                    if (!subscriber.isUnsubscribed) {
+                        subscriber.onNext(response)
+                        subscriber.onCompleted()
+                    }
+                } catch (error: Exception) {
+                    if (!subscriber.isUnsubscribed) {
+                        subscriber.onError(error)
+                    }
+                }
+            }
+
+            override fun unsubscribe() {
+                call.cancel()
+            }
+
+            override fun isUnsubscribed(): Boolean {
+                return call.isCanceled()
+            }
+        }
+
+        subscriber.add(requestArbiter)
+        subscriber.setProducer(requestArbiter)
+    }
+}
+
+// Based on https://github.com/gildor/kotlin-coroutines-okhttp
+//suspend fun Call.await(assertSuccess: Boolean = false): Response {
+//    return suspendCancellableCoroutine { continuation ->
+//        enqueue(
+//            object : Callback {
+//                override fun onResponse(call: Call, response: Response) {
+//                    if (assertSuccess && !response.isSuccessful) {
+//                        continuation.resumeWithException(Exception("HTTP error ${response.code}"))
+//                        return
+//                    }
+//
+//                    continuation.resume(response)
+//                }
+//
+//                override fun onFailure(call: Call, e: IOException) {
+//                    // Don't bother with resuming the continuation if it is already cancelled.
+//                    if (continuation.isCancelled) return
+//                    continuation.resumeWithException(e)
+//                }
+//            }
+//        )
+//
+//        continuation.invokeOnCancellation {
+//            try {
+//                cancel()
+//            } catch (ex: Throwable) {
+//                // Ignore cancel exception
+//            }
+//        }
+//    }
+//}
+
+fun Call.asObservableSuccess(): Observable<Response> {
+    return asObservable().doOnNext { response ->
+        if (!response.isSuccessful) {
+            response.close()
+            throw Exception("HTTP error ${response.code}")
+        }
+    }
+}
+
+//fun OkHttpClient.newCallWithProgress(request: Request, listener: ProgressListener): Call {
+//    val progressClient = newBuilder()
+//        .cache(null)
+//        .addNetworkInterceptor { chain ->
+//            val originalResponse = chain.proceed(chain.request())
+//            originalResponse.newBuilder()
+//                .body(ProgressResponseBody(originalResponse.body!!, listener))
+//                .build()
+//        }
+//        .build()
+//
+//    return progressClient.newCall(request)
+//}
+
+fun OkHttpClient.newCallWithProgress(request: Request, listener: ProgressListener): Call {
+    val progressClient = newBuilder()
+        .cache(null)
+//        .addNetworkInterceptor { chain ->
+//            val originalResponse = chain.proceed(chain.request())
+//            originalResponse.newBuilder()
+//                .body(ProgressResponseBody(originalResponse.body!!, listener))
+//                .build()
+//        }
+        .build()
+
+    return progressClient.newCall(request)
+}

server/src/main/kotlin/eu/kanade/tachiyomi/network/ProgressListener.kt

@@ -0,0 +1,5 @@
+package eu.kanade.tachiyomi.network
+
+interface ProgressListener {
+    fun update(bytesRead: Long, contentLength: Long, done: Boolean)
+}

server/src/main/kotlin/eu/kanade/tachiyomi/network/Requests.kt

@@ -0,0 +1,38 @@
+package eu.kanade.tachiyomi.network
+
+import okhttp3.CacheControl
+import okhttp3.FormBody
+import okhttp3.Headers
+import okhttp3.Request
+import okhttp3.RequestBody
+import java.util.concurrent.TimeUnit.MINUTES
+
+private val DEFAULT_CACHE_CONTROL = CacheControl.Builder().maxAge(10, MINUTES).build()
+private val DEFAULT_HEADERS = Headers.Builder().build()
+private val DEFAULT_BODY: RequestBody = FormBody.Builder().build()
+
+fun GET(
+    url: String,
+    headers: Headers = DEFAULT_HEADERS,
+    cache: CacheControl = DEFAULT_CACHE_CONTROL
+): Request {
+    return Request.Builder()
+        .url(url)
+        .headers(headers)
+        .cacheControl(cache)
+        .build()
+}
+
+fun POST(
+    url: String,
+    headers: Headers = DEFAULT_HEADERS,
+    body: RequestBody = DEFAULT_BODY,
+    cache: CacheControl = DEFAULT_CACHE_CONTROL
+): Request {
+    return Request.Builder()
+        .url(url)
+        .post(body)
+        .headers(headers)
+        .cacheControl(cache)
+        .build()
+}