The easiest HTTP networking library for Kotlin/Android.
- Support basic HTTP GET/POST/PUT/DELETE/HEAD/PATCH in a fluent style interface
- Support both asynchronous and blocking requests
- Download file
- Upload file (multipart/form-data)
- Cancel in-flight request
- Request timeout
- Configuration manager by using
FuelManager
- Debug log / cUrl log
- Support response deserialization into plain old object (both Kotlin & Java)
- Automatically invoke handler on Android Main Thread when using Android Module
- Special test mode for easier testing
- Support for reactive programming via RxJava 2.x and Project Reactor 3.x
- Google Components LiveData support
- Built-in object serialization module (Gson, Jackson, Moshi, Forge) ✨
- Support Kotlin's Coroutines module
- API Routing
- Result - The modelling for success/failure of operations in Kotlin
- Android SDK - Android SDK
- Live Data - Android Architecture Components - LiveData
- RxJava - RxJava – Reactive Extensions for the JVM
- Coroutines - Kotlin Coroutines - Library support for Kotlin coroutines
- Kotlinx Serialization - Kotlinx Serialization - Kotlin cross-platform / multi-format serialization
- Gson - Gson - A Java serialization/deserialization library to convert Java Objects into JSON and back
- Jackson - Jackson - The JSON library for Java
- Moshi - Moshi - A modern JSON library for Android and Java
- Forge - Forge - Functional style JSON parsing written in Kotlin
- Project Reactor - Project Reactor - Implementation of Reactive Streams standard
repositories {
jcenter()
}
dependencies {
compile 'com.github.kittinunf.fuel:fuel:<latest-version>' //for JVM
compile 'com.github.kittinunf.fuel:fuel-android:<latest-version>' //for Android
compile 'com.github.kittinunf.fuel:fuel-livedata:<latest-version>' //for LiveData support
compile 'com.github.kittinunf.fuel:fuel-rxjava:<latest-version>' //for RxJava support
compile 'com.github.kittinunf.fuel:fuel-coroutines:<latest-version>' //for Kotlin Coroutines support
compile 'com.github.kittinunf.fuel:fuel-gson:<latest-version>' //for Gson support
compile 'com.github.kittinunf.fuel:fuel-jackson:<latest-version>' //for Jackson support
compile 'com.github.kittinunf.fuel:fuel-moshi:<latest-version>' //for Moshi support
compile 'com.github.kittinunf.fuel:fuel-forge:<latest-version>' //for Forge support
compile 'com.github.kittinunf.fuel:fuel-reactor:<latest-version>' //for Reactor support
}
- There are two samples, one is in Kotlin and another one in Java.
- Kotlin
//an extension over string (support GET, PUT, POST, DELETE with httpGet(), httpPut(), httpPost(), httpDelete())
"https://httpbin.org/get".httpGet().responseString { request, response, result ->
//do something with response
when (result) {
is Result.Failure -> {
val ex = result.getException()
}
is Result.Success -> {
val data = result.get()
}
}
}
//if we set baseURL beforehand, simply use relativePath
FuelManager.instance.basePath = "https://httpbin.org"
"/get".httpGet().responseString { request, response, result ->
//make a GET to https://httpbin.org/get and do something with response
val (data, error) = result
if (error == null) {
//do something when success
} else {
//error handling
}
}
//if you prefer this a little longer way, you can always do
//get
Fuel.get("https://httpbin.org/get").responseString { request, response, result ->
//do something with response
result.fold({ d ->
//do something with data
}, { err ->
//do something with error
})
}
- Java
//get
Fuel.get("https://httpbin.org/get", params).responseString(new Handler<String>() {
@Override
public void failure(Request request, Response response, FuelError error) {
//do something when it is failure
}
@Override
public void success(Request request, Response response, String data) {
//do something when it is successful
}
});
You can also wait for the response. It returns the same parameters as the async version, but it blocks the thread. It supports all the features of the async version.
- Kotlin
val (request, response, result) = "https://httpbin.org/get".httpGet().responseString() // result is Result<String, FuelError>
- Java
try {
Triple<Request, Response, String> data = Fuel.get("https://www.google.com").responseString();
Request request = data.getFirst();
Response response = data.getSecond();
Result<String,FuelError> text = data.getThird();
} catch (Exception networkError) {
}
Fuel.get("https://httpbin.org/get").response { request, response, result ->
println(request)
println(response)
val (bytes, error) = result
if (bytes != null) {
println(bytes)
}
}
-
Result is a functional style data structure that represents data that contains result of Success or Failure but not both. It represents the result of an action that can be success (with result) or error.
-
Working with result is easy. You could fold, destructure as because it is just a data class or do a simple
when
checking whether it is Success or Failure.
fun response(handler: (Request, Response, Result<ByteArray, FuelError>) -> Unit)
fun responseString(handler: (Request, Response, Result<String, FuelError>) -> Unit)
requires the android extension
fun responseJson(handler: (Request, Response, Result<Json, FuelError>) -> Unit)
val jsonObject = json.obj() //JSONObject
val jsonArray = json.array() //JSONArray
fun <T> responseObject(deserializer: ResponseDeserializable<T>, handler: (Request, Response, Result<T, FuelError>) -> Unit)
Fuel.post("https://httpbin.org/post").response { request, response, result ->
}
//if you have body to post it manually
Fuel.post("https://httpbin.org/post").jsonBody("{ \"foo\" : \"bar\" }").response { request, response, result ->
}
Fuel.put("https://httpbin.org/put").response { request, response, result ->
}
Fuel.delete("https://httpbin.org/delete").response { request, response, result ->
}
Fuel.head("https://httpbin.org/get").response { request, response, result ->
// request body should be empty.
}
- The default
client
isHttpClient
which is a thin wrapper overjava.net.HttpUrlConnnection
.java.net.HttpUrlConnnection
does not support aPATCH
method.HttpClient
convertsPATCH
requests to aPOST
request and adds aX-HTTP-Method-Override: PATCH
header. While this is a semi-standard industry practice not all APIs are configured to accept this header by default.
Fuel.patch("https://httpbin.org/patch").response { request, response, result ->
// request body should be empty.
}
Connect is not supported by the Java JVM via the regular HTTP clients, and is therefore not supported.
There are no convenience methods for making an OPTIONS request, but you can still make one directly:
Fuel.request(Method.OPTIONS, "https://httpbin.org/anything").response { request, response, result ->
}
There are no convenience methods for making an TRACE request, but you can still make one directly:
Fuel.request(Method.TRACE, "https://httpbin.org/anything").response { request, response, result ->
}
- Use
toString()
method to Log (request|response)
Log.d("log", request.toString())
//print and header detail
//request
--> GET (https://httpbin.org/get?key=value)
Body : (empty)
Headers : (2)
Accept-Encoding : compress;q=0.5, gzip;q=1.0
Device : Android
//response
<-- 200 (https://httpbin.org/get?key=value)
- Also support cUrl string to Log request, make it very easy to cUrl on command line
Log.d("cUrl log", request.cUrlString())
//print
curl -i -X POST -d "foo=foo&bar=bar&key=value" -H "Accept-Encoding:compress;q=0.5, gzip;q=1.0" -H "Device:Android" -H "Content-Type:application/x-www-form-urlencoded" "https://httpbin.org/post"
- URL encoded style for GET & DELETE request
Fuel.get("https://httpbin.org/get", listOf("foo" to "foo", "bar" to "bar")).response { request, response, result -> {
//resolve to https://httpbin.org/get?foo=foo&bar=bar
}
Fuel.delete("https://httpbin.org/delete", listOf("foo" to "foo", "bar" to "bar")).response { request, response, result ->
//resolve to https://httpbin.org/delete?foo=foo&bar=bar
}
- Array support for GET requests
Fuel.get("https://httpbin.org/get", listOf("foo" to "foo", "dwarf" to arrayOf("grumpy","happy","sleepy","dopey"))).response { request, response, result -> {
//resolve to https://httpbin.org/get?foo=foo&dwarf[]=grumpy&dwarf[]=happy&dwarf[]=sleepy&dwarf[]=dopey
}
- Support x-www-form-urlencoded for PUT & POST
Fuel.post("https://httpbin.org/post", listOf("foo" to "foo", "bar" to "bar")).response { request, response, result ->
//http body includes foo=foo&bar=bar
}
Fuel.put("https://httpbin.org/put", listOf("foo" to "foo", "bar" to "bar")).response { request, response, result ->
//http body includes foo=foo&bar=bar
}
Default timeout for a request is 15000 milliseconds. Default read timeout for a request is 15000 milliseconds.
- Kotlin
val timeout = 5000 // 5000 milliseconds = 5 seconds.
val timeoutRead = 60000 // 60000 milliseconds = 1 minute.
"https://httpbin.org/get".httpGet().timeout(timeout).timeoutRead(timeoutRead).responseString { request, response, result -> }
- Java
int timeout = 5000 // 5000 milliseconds = 5 seconds.
int timeoutRead = 60000 // 60000 milliseconds = 1 minute.
Fuel.get("https://httpbin.org/get", params).timeout(timeout).timeoutRead(timeoutRead).responseString(new Handler<String>() {
@Override
public void failure(Request request, Response response, FuelError error) {
//do something when it is failure
}
@Override
public void success(Request request, Response response, String data) {
//do something when it is successful
}
});
Fuel.download("https://httpbin.org/bytes/32768").destination { response, url ->
File.createTempFile("temp", ".tmp")
}.response { req, res, result ->
}
Fuel.download("https://httpbin.org/bytes/32768").destination { response, url ->
File.createTempFile("temp", ".tmp")
}.progress { readBytes, totalBytes ->
val progress = readBytes.toFloat() / totalBytes.toFloat()
}.response { req, res, result ->
}
Fuel.upload("/post").source { request, url ->
File.createTempFile("temp", ".tmp");
}.responseString { request, response, result ->
}
//by default upload use Method.POST, unless it is specified as something else
Fuel.upload("/put", Method.PUT).source { request, url ->
File.createTempFile("temp", ".tmp");
}.responseString { request, response, result ->
// calls to https://example.com/api/put with PUT
}
//upload with multiple files
Fuel.upload("/post").sources { request, url ->
listOf(
File.createTempFile("temp1", ".tmp"),
File.createTempFile("temp2", ".tmp")
)
}.name {
"temp"
}.responseString { request, response, result ->
}
Fuel.upload("/post").dataParts { request, url ->
listOf(
//DataPart takes a file, and you can specify the name and/or type
DataPart(File.createTempFile("temp1", ".tmp"), "image/jpeg"),
DataPart(File.createTempFile("temp2", ".tmp"), "file2"),
DataPart(File.createTempFile("temp3", ".tmp"), "third-file", "image/jpeg")
)
}.responseString { request, response, result ->
...
}
val formData = listOf("Email" to "mail@example.com", "Name" to "Joe Smith" )
Fuel.upload("/post", param = formData)
//Upload normally requires a file, but we can give it an empty list of `DataPart`
.dataParts { request, url -> listOf<DataPart>() }
.responseString { request, response, result ->
...
}
Fuel.upload("/post").blob { request, url ->
Blob("filename.png", someObject.length, { someObject.getInputStream() })
}
- Support Basic Authentication right off the box
val username = "username"
val password = "abcd1234"
Fuel.get("https://httpbin.org/basic-auth/$user/$password").authenticate(username, password).response { request, response, result ->
}
- By default, the valid range for HTTP status code will be (200..299).
- If one wants to cancel on-going request, one could call
cancel
on the request object
val request = Fuel.get("https://httpbin.org/get").response { request, response, result ->
// if request is cancelled successfully, response callback will not be called. Interrupt callback (if provided) will be called instead
}
//later
request.cancel() //this will cancel on-going request
- Also, interrupt request can be further processed with interrupt callback
val request = Fuel.get("https://httpbin.org/get").interrupt { request ->
println("${request.url} was interrupted and cancelled")
}.response { request, response, result ->
// if request is cancelled successfully, response callback will not be called. Interrupt callback (if provided) will be called instead
}
request.cancel()
- Fuel provides built-in support for response deserialization. Here is how one might want to use Fuel together with Gson
//User Model
data class User(val firstName: String = "",
val lastName: String = "") {
//User Deserializer
class Deserializer : ResponseDeserializable<User> {
override fun deserialize(content: String) = Gson().fromJson(content, User::class.java)
}
}
//Use httpGet extension
"https://www.example.com/user/1".httpGet().responseObject(User.Deserializer()) { req, res, result ->
//result is of type Result<User, Exception>
val (user, err) = result
println(user.firstName)
println(user.lastName)
}
- Fuel also provides a built in support for Gson Deserialization. This is possible by including the Gson module in your dependency block.
data class HttpBinUserAgentModel(var userAgent: String = "")
Fuel.get("/user-agent").responseObject<HttpBinUserAgentModel> { _, _, result ->
}
requires the kotlinx-serialization extension requires kotlinx.serialization
@Serializable
data class HttpBinUserAgentModel(var userAgent: String = "")
Fuel.get("/user-agent").responseObject<HttpBinUserAgentModel> { _, _, result ->
}
this is by default strict and will reject unknown keys, for that you can pass a custom JSOn instance
JSON(nonstrict = true)
@Serializable
data class HttpBinUserAgentModel(var userAgent: String = "")
Fuel.get("/user-agent").responseObject<HttpBinUserAgentModel>(json = JSON(nonstrict = true)) { _, _, result ->
}
kotlinx.serialization can not always guess the correct serialzer to use, when generics are involved for example
@Serializable
data class HttpBinUserAgentModel(var userAgent: String = "")
Fuel.get("/list/user-agent").responseObject<HttpBinUserAgentModel>(loader = HttpBinUserAgentModel.serilaizer().list) { _, _, result ->
}
it can be used with coroutines by using kotlinxDeserilaizerOf()
it takes the same json
and loader
as parameters
@Serializable
data class HttpBinUserAgentModel(var userAgent: String = "")
Fuel.get("/user-agent").awaitResponseObject<HttpBinUserAgentModel>(kotlinxDeserializerOf()) { _, _, result ->
}
- There are 4 methods to support response deserialization depending on your needs (also depending on JSON parsing library of your choice), and you are required to implement only one of them.
public fun deserialize(bytes: ByteArray): T?
public fun deserialize(inputStream: InputStream): T?
public fun deserialize(reader: Reader): T?
public fun deserialize(content: String): T?
- Another example may be parsing a website that is not UTF-8. By default, Fuel serializes text as UTF-8, we need to define our deserializer as such
object Windows1255StringDeserializer : ResponseDeserializable<String> {
override fun deserialize(bytes: ByteArray): String {
return String(bytes, "windows-1255")
}
}
-
Use singleton
FuelManager.instance
to manage global configurations. -
basePath
is used to manage common root path. Great usage is for your static API endpoint.
FuelManager.instance.basePath = "https://httpbin.org"
Fuel.get("/get").response { request, response, result ->
//make request to https://httpbin.org/get because Fuel.{get|post|put|delete} use FuelManager.instance to make HTTP request
}
baseHeaders
is to manage common HTTP header pairs in format ofMap<String, String>>
.
FuelManager.instance.baseHeaders = mapOf("Device" to "Android")
-
Headers
can be add to a request via the methodsfun header(pairs: Map<String, Any>?): Request
orfun header(vararg pairs: Pair<String, Any>?)
. -
The latter method does support multiple values for the same key however as
fun header(pairs: Map<String, Any>?): Request
takes a map this method can not support multiple values for the same key as per the definition of the map.
Fuel.get("/get").response { request, response, result ->
//make request to https://httpbin.org/get with global device header (Device : Android)
}
baseParams
is used to manage commonkey=value
query param, which will be automatically included in all of your subsequent requests in format ofList<Pair<String, Any?>>
(Any
is converted toString
bytoString()
method)
FuelManager.instance.baseParams = listOf("api_key" to "1234567890")
Fuel.get("/get").response { request, response, result ->
//make request to https://httpbin.org/get?api_key=1234567890
}
-
client
is a raw HTTP client driver. Generally, it is responsible to makeRequest
intoResponse
. Default isHttpClient
which is a thin wrapper overjava.net.HttpUrlConnnection
. You could use any httpClient of your choice by conforming toclient
protocol, and set back toFuelManager.instance
to kick off the effect. -
keyStore
is configurable by user. By default it isnull
. -
socketFactory
can be supplied by user. IfkeyStore
is not null,socketFactory
will be derived from it. -
hostnameVerifier
is configurable by user. By default, it usesHttpsURLConnection.getDefaultHostnameVerifier()
. -
requestInterceptors
responseInterceptors
is a side-effect to add toRequest
and/orResponse
objects. For example, one might wanna print cUrlString style for every request that hits server in DEBUG mode.
val manager = FuelManager()
if (BUILD_DEBUG) {
manager.addRequestInterceptor(cUrlLoggingRequestInterceptor())
}
val (request, response, result) = manager.request(Method.GET, "https://httpbin.org/get").response() //it will print curl -i -H "Accept-Encoding:compress;q=0.5, gzip;q=1.0" "https://httpbin.org/get"
- Another example is that you might wanna add data into your Database, you can achieve that with providing
responseInterceptors
such as
inline fun <reified T> DbResponseInterceptor() =
{ next: (Request, Response) -> Response ->
{ req: Request, res: Response ->
val db = DB.getInstance()
val instance = Parser.getInstance().parse(res.data, T::class)
db.transaction {
it.copyToDB(instance)
}
next(req, res)
}
}
manager.addResponseInterceptor(DBResponseInterceptor<Dog>)
manager.request(Method.GET, "https://www.example.com/api/dog/1").response() // Db interceptor will be called to intercept data and save into Database of your choice
Testing asynchronized calls can be somehow hard without special care. That's why Fuel has a special test mode with make all the requests blocking, for tests.
Fuel.testMode {
timeout = 15000 // Optional feature, set all requests' timeout to this value.
}
In order to disable test mode, just call Fuel.regularMode()
- Fuel supports RxJava right off the box.
"https://www.example.com/photos/1".httpGet().rx_object(Photo.Deserializer()).subscribe {
//do something
}
- There are 6 extensions over
Request
that provide RxJava 2.xSingle<Result<T, FuelError>>
as return type.
fun Request.rx_response(): Single<Pair<Response, Result<ByteArray, FuelError>>>
fun Request.rx_responseString(charset: Charset): Single<Pair<Response, Result<String, FuelError>>>
fun <T : Any> Request.rx_responseObject(deserializable: Deserializable<T>): Single<Pair<Response, Result<T, FuelError>>>
fun Request.rx_data(): Single<Result<ByteArray, FuelError>>
fun Request.rx_string(charset: Charset): Single<Result<String, FuelError>>
fun <T : Any> Request.rx_object(deserializable: Deserializable<T>): Single<Result<T, FuelError>>
- Fuel supports LiveData
Fuel.get("www.example.com/get").liveDataResponse().observe(this) {
//do something
}
In order to organize better your network stack FuelRouting interface allows you to easily setup a Router design pattern.
sealed class WeatherApi: FuelRouting {
override val basePath = "https://www.metaweather.com"
class weatherFor(val location: String): WeatherApi() {}
override val method: Method
get() {
when(this) {
is weatherFor -> return Method.GET
}
}
override val path: String
get() {
return when(this) {
is weatherFor -> "/api/location/search/"
}
}
override val params: List<Pair<String, Any?>>?
get() {
return when(this) {
is weatherFor -> listOf("query" to this.location)
}
}
override val headers: Map<String, String>?
get() {
return null
}
}
// Usage
Fuel.request(WeatherApi.weatherFor("london")).responseJson { request, response, result ->
result.fold(success = { json ->
Log.d("qdp success", json.array().toString())
}, failure = { error ->
Log.e("qdp error", error.toString())
})
}
Coroutines module provides extension functions to wrap a response inside a coroutine and handle its result. The coroutines-based API provides equivalent methods to the standard API (e.g: responseString()
in coroutines is awaitStringResponse()
).
runBlocking {
val (request, response, result) = Fuel.get("https://httpbin.org/ip").awaitStringResponse()
result.fold({ data ->
println(data) // "{"origin":"127.0.0.1"}"
}, { error ->
println("An error of type ${error.exception} happened: ${error.message}")
})
}
There are functions to handle Result
object directly too.
runBlocking {
Fuel.get("https://httpbin.org/ip").awaitStringResult()
.fold({ data ->
println(data) // "{"origin":"127.0.0.1"}"
}, { error ->
println("An error of type ${error.exception} happened: ${error.message}")
})
}
It also provides useful methods to retrieve the ByteArray
,String
or Object
directly. The difference with these implementations is that they throw exception instead of returning it wrapped a FuelError
instance.
runBlocking {
try {
println(Fuel.get("https://httpbin.org/ip").awaitString()) // "{"origin":"127.0.0.1"}"
} catch(exception: Exception) {
println("A network request exception was thrown: ${exception.message}")
}
}
Handling objects other than String
(awaitStringResponse()
) or ByteArray
(awaitByteArrayResponse()
) can be done using awaitObject
, awaitObjectResult
or awaitObjectResponse
.
data class Ip(val origin: String)
object IpDeserializer : ResponseDeserializable<Ip> {
override fun deserialize(content: String) =
jacksonObjectMapper().readValue<Ip>(content)
}
runBlocking {
Fuel.get("https://httpbin.org/ip").awaitObjectResult(IpDeserializer)
.fold({ data ->
println(data.origin) // 127.0.0.1
}, { error ->
println("An error of type ${error.exception} happened: ${error.message}")
})
}
runBlocking {
try {
val data = Fuel.get("https://httpbin.org/ip").awaitObject(IpDeserializer)
println(data.origin) // 127.0.0.1
} catch (exception: Exception) {
when (exception){
is HttpException -> println("A network request exception was thrown: ${exception.message}")
is JsonMappingException -> println("A serialization/deserialization exception was thrown: ${exception.message}")
else -> println("An exception [${exception.javaClass.simpleName}\"] was thrown")
}
}
}
The Reactor module API provides functions starting with the prefix mono
to handle instances of Response
, Result<T, FuelError>
and values directly (String
, ByteArray
, Any
). All functions expose exceptions as FuelError
instance.
Data handling example
Fuel.get("https://icanhazdadjoke.com")
.header("Accept" to "text/plain")
.monoString()
.subscribe(::println)
Error handling example
data class Guest(val name: String)
object GuestMapper : ResponseDeserializable<Guest> {
override fun deserialize(content: String) =
jacksonObjectMapper().readValue<Guest>(content)
}
Fuel.get("/guestName").monoResultObject(GuestMapper)
.map(Result<Guest, FuelError>::get)
.map { (name) -> "Welcome to the party, $name!" }
.onErrorReturn("I'm sorry, your name is not on the list.")
.subscribe(::println)
Response handling example
FuelManager.instance.basePath = "https://httpbin.org"
Fuel.get("/status/404").monoResponse()
.filter(Response::isSuccessful)
.switchIfEmpty(Fuel.get("/status/200").monoResponse())
.map(Response::statusCode)
.subscribe(::println)
If you like Fuel, you might also like other libraries of mine;
- Result - The modelling for success/failure of operations in Kotlin
- Fuse - A simple generic LRU memory/disk cache for Android written in Kotlin
- Forge - Functional style JSON parsing written in Kotlin
- ReactiveAndroid - Reactive events and properties with RxJava for Android SDK
Fuel is brought to you by contributors.
Fuel is released under the MIT license.