riku
2022-01-20 5a0fff8095cd5356f57c181b7e7b820e0f7efacf
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
package com.flightfeather.ducha.module.common
 
import android.arch.lifecycle.MutableLiveData
import cn.flightfeather.thirdappmodule.common.net.NetWorkProgressListener
import cn.flightfeather.thirdappmodule.common.net.ResultCallBack
import cn.flightfeather.thirdappmodule.model.bean.ExcelConfigVo
import cn.flightfeather.thirdappmodule.model.event.FileExportEvent
import cn.flightfeather.thirdappmodule.module.base.BaseViewModel
import cn.flightfeather.thirdappmodule.repository.SearchRepository
import cn.flightfeather.thirdappmodule.util.file.FileUtil
import io.reactivex.Observable
import io.reactivex.android.schedulers.AndroidSchedulers
import io.reactivex.disposables.Disposable
import io.reactivex.schedulers.Schedulers
import okhttp3.ResponseBody
import org.greenrobot.eventbus.EventBus
import org.jetbrains.anko.runOnUiThread
import retrofit2.Response
import java.io.File
import java.util.*
 
/**
 * @author riku
 * Date: 2020/6/13
 */
class FileExportViewModel : BaseViewModel() {
    private val searchRepository = SearchRepository()
 
    val dataList = MutableLiveData<MutableList<File>>().apply { value = mutableListOf() }
    val progress = MutableLiveData<Pair<Long, Long>>()
    val disposableList = mutableListOf<Disposable>()
 
 
    fun getExportFiles() {
        val d = Observable.create<List<File>> { emitter ->
            val file = File(FileUtil.ROOT_PATH)
            var files = emptyArray<File>()
            try {
                files = file.listFiles()
            } catch (e: Exception) {
                e.printStackTrace()
            }
            val resultList = mutableListOf<File>()
            files.forEach {
                if (it.isFile &&
                        (FileUtil.getExtensionName(it.name) == "xls"
                                || FileUtil.getExtensionName(it.name) == "xlsx")
                ) {
                    resultList.add(it)
                }
            }
            emitter.onNext(resultList)
            emitter.onComplete()
        }.subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe {
                    dataList.value?.clear()
                    dataList.value?.addAll(it)
                    dataList.value = dataList.value
                }
 
        disposableList.add(d)
    }
 
    fun exportFile(configVo: ExcelConfigVo, s: () -> Unit) {
        searchRepository.getExcel(configVo, object : ResultCallBack<Response<ResponseBody>> {
            override fun onSuccess(result: Response<ResponseBody>?) {
                result?.let {response ->
                    Observable.create<String> {
                        val fileName = response.headers().get("fileName") ?: "${Date().time}.xls"
                        val path = FileUtil.ROOT_PATH + fileName
                        FileUtil.writeToDisk(response.body()?.byteStream(), path)
                        it.onNext(path)
                    }.subscribeOn(Schedulers.io())
                            .observeOn(AndroidSchedulers.mainThread())
                            .subscribe {
                                EventBus.getDefault().post(FileExportEvent(it))
                                s()
                            }
                }
            }
 
            override fun onFailure() {
 
            }
        }, object : NetWorkProgressListener {
            override fun onProgress(progress: Long, total: Long) {
                application.runOnUiThread {
                    this@FileExportViewModel.progress.value = Pair(progress, total)
                }
            }
        })
    }
 
    fun deleteFile(file: File?) {
        file?.delete()
    }
 
    fun deleteAllFiles() {
        dataList.value?.forEach {
            it.delete()
        }
        dataList.value?.clear()
        dataList.value = dataList.value
    }
 
}