Use Ktor for networking

Select an engine

Ktor offers you multiple HTTP engines to use in your project: Apache, CIO, Android, iOS, and others. Engines differ by sets of supported features or platforms they work on. For the full list of supported HTTP engines, refer to the Ktor documentation.

To use a specific HTTP engine, connect the corresponding Ktor artifact as a dependency, for example:

dependencies { implementation("io.ktor:ktor-client-cio:$ktor_version") } 

dependencies { implementation "io.ktor:ktor-client-cio:$ktor_version" } 

Now you can create an HTTP client with this engine: just pass the engine class as an argument of the HttpClient() constructor.

val client = HttpClient(CIO) 

If you call the HttpClient() constructor without an argument, then one of the engines available to Ktor will be automatically selected at compile time.

val httpClient: HttpClient = HttpClient() 

dependencies { testImplementation("io.ktor:ktor-client-mock:$ktor_version") } 

dependencies { api "io.ktor:ktor-client-mock:$ktor_version" } 

val httpClient: HttpClient = HttpClient(MockEngine) 

Configure the client

Client configuration can be done through a lambda expression with the receiver. In other words, the receiver object of the HttpClientConfig class for a specific HTTP engine through which the entire configuration is performed will be transferred to the lambda, which is transferred as an argument to the HttpClient() function.

To configure the client, pass a lambda expression to the HttpClient() call.

val httpClient = HttpClient { expectSuccess = false ResponseObserver { response -> println("HTTP status: ${response.status.value}") } } 

In this example, the following configuration is used: Receiving HTTP errors in response don’t cause exceptions A ResponseObserver is created that prints response statuses to the standard output.

val client = HttpClient(Android) { engine { connectTimeout = 100_000 socketTimeout = 100_000 proxy = Proxy(Proxy.Type.HTTP, InetSocketAddress("localhost", serverPort)) } } 

val commonMain by getting { dependencies { implementation("io.ktor:ktor-client-auth:$ktor_version") } } 

commonMain { dependencies { implementation "io.ktor:ktor-client-auth:$ktor_version" } } 

val client = HttpClient() { install(Auth) { // providers config ... } } 

val httpClient = HttpClient { install(ResponseObserver) { onResponse { response -> println("HTTP status: ${response.status.value}") } } } 

Method

To define an HTTP method (for example, GET or POST) for a request, provide a value for the method property: a GET request whose result comes as a string:

val htmlContent = httpClient.request<String> { url("https://en.wikipedia.org/wiki/Main_Page") method = HttpMethod.Get } 

a POST request:

val response = httpClient.post<HttpResponse>("http://127.0.0.1:8080/") { headers { append("Authorization", "token") } body = "Command" } 

Ktor provides extension functions for the HttpClient class for using basic HTTP methods: get, post, put, patch, delete, options, head. This is how you use them to send a GET request:

val response = httpClient.get<HttpResponse>("http://127.0.0.1:8080/") { headers { append("Accept", "application/json") } } 

Headers

To add headers to the request, use the headers extension function.

val htmlContent = httpClient.request<String> { url("https://en.wikipedia.org/wiki/Main_Page") method = HttpMethod.Get headers { append("Accept", "application/json") append("Authorization", "oauth token") } } 

Body

To set the body of a request, assign a value to the body property in the HttpRequestBuilder class. You can assign a string or an OutgoingContent object to this property. For example, sending data with a text/plain text MIME type can be implemented as follows:

val htmlContent = httpClient.request<String> { url("http://127.0.0.1:8080/") method = HttpMethod.Post body = TextContent( text = "Body content", contentType = ContentType.Text.Plain ) } 

Response type

To obtain more information in the response, such as HTTP status, you can use the HttpResponse type as the request result:

val response = httpClient.request<HttpResponse> { url("https://en.wikipedia.org/wiki/Main_Page") method = HttpMethod.Get } if (response.status == HttpStatusCode.OK) { // HTTP-200 } 

For more information about the HttpResponse, refer to the Documentation.

You can also obtain the request results in the form of a byte array:

val response = httpClient.request<ByteArray> { url("https://en.wikipedia.org/wiki/Main_Page") method = HttpMethod.Get } 

Multipart requests

To send a multipart request, pass a MultiPartFormDataContent object to the body property. Create this object by calling the MultiPartFormDataContent() constructor with the argument parts: List<PartData>. To create this list, use the FormBuilder builder class. It provides multiple variations of the append function for adding the data. There is also formData builder function, which accepts a lambda with the FormBuilder receiver.

An example of creating a POST request with Multipart data may look as follows:

val request: String = httpClient.post("http://127.0.0.1:8080/") { body = MultiPartFormDataContent( formData { append("key", "value") } ) }