How to use responseProgress method of com.github.kittinunf.fuel.core.Request class

...282     * @see com.github.kittinunf.fuel.core.requests.DownloadRequest.progress283     *284     * @return self285     */286    override fun responseProgress(handler: ProgressCallback): Request {287        executionOptions.responseProgress += handler288        return request289    }290    /**291     * Add a [InterruptCallback] to the [RequestExecutionOptions]292     *293     * @see RequestExecutionOptions.interruptCallbacks294     *295     * @return self296     */297    override fun interrupt(interrupt: InterruptCallback) = request.also {298        it.executionOptions.interruptCallbacks.plusAssign(interrupt)299    }300    /**301     * Overwrite the [Request] [timeout] in milliseconds...

...111                            .requestProgress{readBytes, totalBytes ->112                                val progress = readBytes.toFloat() / totalBytes.toFloat() * 50113                                h.post {progressBar.progress = progress.toInt()}114                            }115                            .responseProgress {readBytes, totalBytes ->116                                val progress = readBytes.toFloat() / totalBytes.toFloat() * 50 + 50117                                h.post {progressBar.progress = progress.toInt()}118                            }119                            .response { result ->120                                val (bytes, error) = result121                                if (error != null) {122                                    println("[error] $error")123                                } else {124                                    val res = BitmapFactory.decodeByteArray(bytes, 0, bytes!!.count())125                                    //runOnUiThread {imagePreview.setImageBitmap(res)}126                                    h.post {127                                        imagePreview.setImageBitmap(res)128                                        progressBar.visibility = GONE129                                        if (res.width > res.height) {130                                            imageWidth = 600131                                            imageHeight = res.height * imageWidth / res.width132                                        } else {133                                            imageHeight = 600134                                            imageWidth = res.width * imageHeight / res.height135                                        }136                                        currentState = "view"137                                    }138                                }139                            }140                    }141                    else if (currentState == "view") {142                        Fuel.upload("$serverAddress/view")143                            .add(BlobDataPart(bis, name = "data", filename = "image.jpg", contentLength = length.toLong()))144                            .add(InlineDataPart(imageHeight.toString(), name = "height"))145                            .add(InlineDataPart(imageWidth.toString(), name = "width"))146                            .requestProgress{readBytes, totalBytes ->147                                val progress = readBytes.toFloat() / totalBytes.toFloat() * 50148                                h.post {progressBar.progress = progress.toInt()}149                            }150                            .responseProgress {readBytes, totalBytes ->151                                val progress = readBytes.toFloat() / totalBytes.toFloat() * 50 + 50152                                h.post {progressBar.progress = progress.toInt()}153                            }154                            .response { result ->155                                val (bytes, error) = result156                                if (error != null) {157                                    println("[error] $error")158                                } else {159                                    h.post {160                                        imagePreview.setImageDrawable(null)161                                        progressBar.visibility = GONE162                                        currentState = "image"163                                    }164                                }...

...55            response = mock.response().withBody(bytes).withDelay(TimeUnit.MILLISECONDS, 200)56        )57        val running = manager.download(mock.path("cancel-response"))58            .fileDestination { _, _ -> file }59            .responseProgress { readBytes, _ ->60                responseWrittenSemaphore.release()61                Thread.sleep(200)62                if (readBytes > 9 * manager.progressBufferSize)63                    fail("Expected request to be cancelled by now")64            }65            .interrupt { interruptedSemaphore.release() }66            .response(expectNoResponseCallbackHandler())67        if (!responseWrittenSemaphore.tryAcquire(3, 5, TimeUnit.SECONDS)) {68            fail("Expected body to be at least ${3 * manager.progressBufferSize} bytes")69        }70        // Cancel while writing body71        running.cancel()72        // Run the request73        if (!interruptedSemaphore.tryAcquire(5, TimeUnit.SECONDS)) {74            fail("Expected request to be cancelled via interruption")75        }76        assertThat(running.isDone, equalTo(true))77        assertThat(running.isCancelled, equalTo(true))78        assertThat("Expected file to be incomplete", file.length() < bytes.size, equalTo(true))79    }80    // Random Test Failure when interruptSemaphore didn't acquired on 5 secs81    @Test82    fun testCancellationInline() {83        val interruptSemaphore = Semaphore(0)84        val bodyReadSemaphore = Semaphore(0)85        mock.chain(86            request = mock.request().withMethod(Method.POST.value).withPath("/cancel-inline"),87            response = mock.reflect().withDelay(TimeUnit.MILLISECONDS, 200)88        )89        val running = FuelManager()90            .request(Method.POST, mock.path("cancel-inline"), listOf("foo" to "bar"))91            .authentication().basic("username", "password")92            .body(93                { ByteArrayInputStream("my-body".toByteArray()).also { bodyReadSemaphore.release() } },94                { "my-body".length.toLong() }95            )96            .interrupt { interruptSemaphore.release() }97            .response(expectNoResponseCallbackHandler())98        if (!bodyReadSemaphore.tryAcquire(5, TimeUnit.SECONDS)) {99            fail("Expected body to be serialized")100        }101        running.cancel()102        if (!interruptSemaphore.tryAcquire(5, TimeUnit.SECONDS)) {103            fail("Expected request to be cancelled via interruption")104        }105        assertThat(running.isDone, equalTo(true))106        assertThat(running.isCancelled, equalTo(true))107    }108    @Test109    fun interruptCallback() {110        val manager = FuelManager()111        val interruptSemaphore = Semaphore(0)112        val responseWrittenCallback = Semaphore(0)113        val bytes = ByteArray(10 * manager.progressBufferSize).apply { Random().nextBytes(this) }114        mock.chain(115            request = mock.request().withMethod(Method.GET.value).withPath("/bytes"),116            response = mock.response()117                .withBody(BinaryBody(bytes, MediaType.OCTET_STREAM))118                .withDelay(TimeUnit.MILLISECONDS, 200)119        )120        val file = File.createTempFile(bytes.toString(), null)121        val running = FuelManager()122            .download(mock.path("bytes"))123            .fileDestination { _, _ -> file }124            .header(Headers.CONTENT_TYPE, "application/octet-stream")125            .responseProgress { _, _ ->126                responseWrittenCallback.release()127                Thread.sleep(200)128            }129            .interrupt { interruptSemaphore.release() }130            .response(expectNoResponseCallbackHandler())131        if (!responseWrittenCallback.tryAcquire(5, TimeUnit.SECONDS)) {132            fail("Expected response to be partially written")133        }134        running.cancel()135        if (!interruptSemaphore.tryAcquire(5, TimeUnit.SECONDS)) {136            fail("Expected request to be cancelled via interruption")137        }138        assertThat(running.isDone, equalTo(true))139        assertThat(running.isCancelled, equalTo(true))...

...124        Fuel.get("$url/json")125            .requestProgress { _, _ ->126                println("Request wait")127            }128            .responseProgress{ _, _ ->129                println("Response wait")130            }131            .responseJson{ _, _, result ->132                println(result)133                println("OK")134            }135    }136    @Test137    fun testAsync() {138        println("Waiting test")139        val (_, _, result) = Fuel.get("$url/json")140                                 .responseJson()141        result.fold(success = { json ->142            val jsonobj = json.obj()...

...37                    next(req)38                }39            }40            .get(tex)41            .responseProgress { readBytes, totalBytes ->42                val percent = readBytes.toFloat().div(totalBytes).times(100)43                JSONMessage.actionbar("リソースパックをダウンロード中... ($percent %)", player)44            }45            .response()46        JSONMessage.create()47            .then("$prefix レスポンスは ")48            .then("${response.statusCode} (${response.responseMessage})")49            .tooltip(buildString {50                append("${CC.YELLOW}URL: ${CC.RESET}${response.url}")51                append("\n")52                append(response.headers53                    .map { "${CC.AQUA}${it.key}: ${CC.RESET}${it.value.joinToString(" ")}" }54                    .joinToString("\n"))55            })...

...47    fun streamDestination(destination: StreamDestinationCallback): DownloadRequest {48        destinationCallback = destination49        return request50    }51    fun progress(progress: ProgressCallback) = responseProgress(progress)52    private fun transformResponse(request: Request, response: Response): Response {53        val (output, inputCallback) = this.destinationCallback(response, request)54        output.use { outputStream ->55            response.body.toStream().use { inputStream ->56                inputStream.copyTo(out = outputStream)57            }58        }59        // This allows the stream to be written to disk first and then return the written file.60        // We can not calculate the length here because inputCallback might not return the actual output as we write it.61        return response.copy(body = DefaultBody.from(inputCallback, null))62    }63    companion object {64        val FEATURE: String = DownloadRequest::class.java.canonicalName65        fun enableFor(request: Request) = request.enabledFeatures...

...46            response = mock.response().withDelay(Delay.seconds(1)).withBody(BinaryBody(downloadData, MediaType.OCTET_STREAM))47        )48        var progressCalls = 049        val (request, response, result) = threadSafeFuel.request(Method.GET, mock.path("download"))50            .responseProgress { _, _ -> progressCalls += 1 }51            .also { println("Downloading $length bytes to memory") }52            .responseString()53        val (data, error) = result54        assertThat(request, notNullValue())55        assertThat(response, notNullValue())56        assertThat("Expected data, actual error $error.", data, notNullValue())57        // Probably around 9 (8 times a buffer write, and the final closing -1 write)58        assertThat("Expected progress to be called at least (total size/buffer size), actual $progressCalls calls",59            progressCalls > length / threadSafeFuel.progressBufferSize,60            equalTo(true)61        )62    }63}...

...39                    if (newUrl.host != request.url.host)40                        it.headers.remove(Headers.AUTHORIZATION)41                }42                .requestProgress(request.executionOptions.requestProgress)43                .responseProgress(request.executionOptions.responseProgress)44                .let {45                    if (newMethod === request.method && !request.body.isEmpty() && !request.body.isConsumed())46                        it.body(request.body)47                    else48                        it49                }50            // Redirect51            next(request, newRequest.response().second)52        }53    }...

1    println("readBytes: $readBytes")2    println("totalBytes: $totalBytes")3}.response { _, _, result ->4    result.fold({ d ->5        println(d)6    }, { err ->7        println(err)8    })9}10    println("readBytes: $readBytes")11    println("totalBytes: $totalBytes")12}.response { _, _, result ->13    result.fold({ d ->14        println(d)15    }, { err ->16        println(err)17    })18}19    println("readBytes: $readBytes")20    println("totalBytes: $totalBytes")21}.response { _, _, result ->22    result.fold({ d ->23        println(d)24    }, { err ->25        println(err)26    })27}28    println("readBytes: $readBytes")29    println("totalBytes: $totalBytes")30}.response { _, _, result ->31    result.fold({ d ->32        println(d)33    }, { err ->34        println(err)35    })36}37    println("readBytes: $readBytes")38    println("totalBytes: $totalBytes")39}.response { _, _, result ->40    result.fold({ d ->41        println(d)42    }, { err ->43        println(err)44    })45}

1println("readBytes: $readBytes")2println("totalBytes: $totalBytes")3}4println("readBytes: $readBytes")5println("totalBytes: $totalBytes")6}.third7println("readBytes: $readBytes")8println("totalBytes: $totalBytes")9}10println("readBytes: $readBytes")11println("totalBytes: $totalBytes")12}13println("readBytes: $readBytes")14println("totalBytes: $totalBytes")15}16println("readBytes: $readBytes")17println("totalBytes: $totalBytes")18}19println("readBytes: $readBytes")20println("totalBytes: $totalBytes")21}

1val (request, response, result) = Fuel.upload(url)2        .source { request, url ->3            val file = File(url)4            file.inputStream()5        }6        .fileBody(file)7        .responseProgress { readBytes, totalBytes ->8            println("percentage: $percentage")9        }10        .response()11val (request, response, result) = Fuel.upload(url)12        .source { request, url ->13            val file = File(url)14            file.inputStream()15        }16        .fileBody(file)17        .response()18        .responseProgress { readBytes, totalBytes ->19            println("percentage: $percentage")20        }21val (request, response, result) = Fuel.upload(url)22        .source { request, url ->23            val file = File(url)24            file.inputStream()25        }26        .fileBody(file)27        .response()28        .responseProgress { readBytes, totalBytes ->29            println("percentage: $percentage")30        }31val (request, response, result) = Fuel.upload(url)32        .source { request, url ->33            val file = File(url)34            file.inputStream()35        }36        .fileBody(file)37        .response()38        .component3()39        .responseProgress { readBytes, totalBytes ->40            println("percentage: $percentage")41        }42val (request, response, result) = Fuel.upload(url)43        .source { request, url ->44            val file = File(url)45            file.inputStream()46        }47        .fileBody(file)48        .response()49        .responseProgress { readBytes

1val (request, response, result) = FuelManager.instance.get("f=sl1d1t1&s=MSFT+GOOG+AAPL+FB+TWTR", listOf("f" to "sl1d1t1", "s" to "MSFT+GOOG+AAPL+FB+TWTR")).responseProgress { readBytes, totalBytes ->2    Log.d(TAG, "readBytes: $readBytes, totalBytes: $totalBytes")3}4Log.d(TAG, "request: $request")5Log.d(TAG, "response: $response")6Log.d(TAG, "result: $result")7Log.d(TAG, "request: $request")8Log.d(TAG, "response: $response")9Log.d(TAG, "result: $result")10val (request, response, result) = FuelManager.instance.get("f=sl1d1t1&s=MSFT+GOOG+AAPL+FB+TWTR", listOf("f" to "sl1d1t1", "s" to "MSFT+GOOG+AAPL+FB+TWTR")).responseProgress { readBytes, totalBytes ->11    Log.d(TAG, "readBytes: $readBytes, totalBytes: $totalBytes")12}13Log.d(TAG, "request: $request")14Log.d(TAG, "response: $response")15Log.d(TAG, "result: $result")16Log.d(TAG, "request: $request")17Log.d(TAG, "response: $response")18Log.d(TAG, "result: $result")19val (request, response, result) = Fuel