Fresco 下载各种格式图片方法

查看网上关于通过InputStream一般是这么写的

public void saveBit(InputStream inStream) throws IOException{
ByteArrayOutputStream outStream = new ByteArrayOutputStream(); 
//创建一个Buffer字符串 
byte[] buffer = new byte[1024]; 
//每次读取的字符串长度，如果为-1，代表全部读取完毕 
int len = 0; 
//使用一个输入流从buffer里把数据读取出来 
while( (len=inStream.read(buffer)) != -1 ){ 
//用输出流往buffer里写入数据，中间参数代表从哪个位置开始读，len代表读取的长度 
outStream.write(buffer, 0, len); 
} 
//关闭输入流 
inStream.close(); 
//把outStream里的数据写入内存 

//得到图片的二进制数据，以二进制封装得到数据，具有通用性 
byte[] data = outStream.toByteArray(); 
//new一个文件对象用来保存图片，默认保存当前工程根目录 
File imageFile = new File("E:/BeautyGirl.jpg"); 
//创建输出流 
FileOutputStream fileOutStream = new FileOutputStream(imageFile); 
//写入数据 
fileOutStream .write(data); 

}

但是 (len=inStream.read(buffer)) != -1 在kotlin中等式不是一个表达式
因此需要使用also方法 参考https://blog.csdn.net/u011976726/article/details/79125950

inputStream.read(buffer).also { length = it } != -1

Fresco官网有https://www.fresco-cn.org/docs/datasources-datasubscribers.html
关于数据源下载处理方法，一些比较复杂、耗时的操作，并且不涉及UI（如数据库读写、文件IO）我这里用的是Executors.newSingleThreadExecutor()

   object FrescoImageLoader {
    val SAVE_DIR = File(Environment.getExternalStorageDirectory(), "pic")
    fun downImageView(url: String?, onSuccess:(File)-> Unit , onFailure: ((Throwable) -> Unit)? = null) {
        if (url.isNullOrEmpty()) {
            onFailure?.invoke(IOException("未指定Url"))
        }
        val dataSource: DataSource<CloseableReference<PooledByteBuffer>> = Fresco.getImagePipeline().fetchEncodedImage(ImageRequest.fromUri(url), null)
        dataSource.subscribe(object : BaseDataSubscriber<CloseableReference<PooledByteBuffer>?>() {
            override fun onFailureImpl(dataSource: DataSource<CloseableReference<PooledByteBuffer>?>?) {
                onFailure?.invoke(IOException("加载失败"))
            }

            override fun onNewResultImpl(dataSource: DataSource<CloseableReference<PooledByteBuffer>?>?) {
                if (dataSource?.isFinished == false) {
                    return
                }
                var ref = dataSource?.result
                if (ref != null) {
                    try {
                        val result = ref.get()
                        val inputStream: InputStream = PooledByteBufferInputStream(result)
                        try {
                            val imageFormat = ImageFormatChecker.getImageFormat(inputStream)
                            val suffix = when (imageFormat) {
                                DefaultImageFormats.JPEG -> ".jpg"
                                DefaultImageFormats.PNG -> ".png"
                                DefaultImageFormats.GIF -> ".gif"
                                DefaultImageFormats.BMP -> ".bmp"
                                else -> ".jpg"
                            }
                            val name = "pic_" + System.currentTimeMillis() + suffix
                            val distFile = FileUtil.generateUniqueFile(SAVE_DIR, name)
                            val out : FileOutputStream = FileOutputStream(distFile)
                            val buffer = ByteArray(1024)
                            var length = 0
                            /*
                            val outStream = ByteArrayOutputStream()
                            inputStream.use { input ->
                                outStream.use {
                                    while (inputStream.read(buffer).also { length = it } != -1){
                                        it.write(buffer, 0, length)
                                    }
                                }
                            }
                            //得到图片的二进制数据，以二进制封装得到数据，具有通用性
                            val data = outStream.toByteArray()
                            out.write(data)*/

                            inputStream.use {input ->
                                out.use {
                                    while (input.read(buffer).also { length = it } != -1){
                                        it.write(buffer,0, length)
                                    }
                                }
                            }
                            inputStream.closeSafe()
                            out.closeSafe()
                            if (distFile != null){
                                onSuccess(distFile)
                            } else {
                                onFailure?.invoke(IOException("下载失败"))
                            }
                        } catch (e: Exception) {
                            onFailure?.invoke(IOException("下载失败"))
                        } finally {
                            Closeables.closeQuietly(inputStream)
                        }
                    } catch (e: Exception) {
                        onFailure?.invoke(IOException("下载失败"))
                    } finally {
                        CloseableReference.closeSafely(ref)
                        ref = null
                    }
                }
            }
        }, Executors.newSingleThreadExecutor())
    }
}