ScanPreviewViewModel.kt

package org.totschnig.ocr

import android.app.Activity
import android.app.Application
import android.content.Intent
import android.net.Uri
import androidx.exifinterface.media.ExifInterface
import androidx.lifecycle.AndroidViewModel
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import org.totschnig.myexpenses.MyApplication
import org.totschnig.myexpenses.activity.OCR_REQUEST
import org.totschnig.myexpenses.feature.OcrFeatureProvider.Companion.ACTION
import org.totschnig.myexpenses.feature.OcrFeatureProvider.Companion.MIME_TYPE
import org.totschnig.myexpenses.feature.OcrResult
import org.totschnig.myexpenses.util.AppDirHelper
import java.io.File
import javax.inject.Inject

class ScanPreviewViewModel(application: Application) : AndroidViewModel(application) {
    var running: Boolean = false

    var orientation = 0

    @Inject
    lateinit var ocrFeature: OcrFeature

    private val result = MutableLiveData<Result<OcrResult>>()

    fun getResult(): LiveData<Result<OcrResult>> = result

    init {
        DaggerOcrComponent.builder().appComponent((application as MyApplication).appComponent).build().inject(this)
    }

    fun rotate(right: Boolean, scanFilePath: String, action: () -> Unit) {
        viewModelScope.launch {
            withContext(Dispatchers.Default) {
                val exif = ExifInterface(scanFilePath)
                when (exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL)) {
                    ExifInterface.ORIENTATION_NORMAL -> if (right) ExifInterface.ORIENTATION_ROTATE_90 else ExifInterface.ORIENTATION_ROTATE_270
                    ExifInterface.ORIENTATION_ROTATE_90 -> if (right) ExifInterface.ORIENTATION_ROTATE_180 else ExifInterface.ORIENTATION_NORMAL
                    ExifInterface.ORIENTATION_ROTATE_180 -> if (right) ExifInterface.ORIENTATION_ROTATE_270 else ExifInterface.ORIENTATION_ROTATE_90
                    ExifInterface.ORIENTATION_ROTATE_270 -> if (right) ExifInterface.ORIENTATION_NORMAL else ExifInterface.ORIENTATION_ROTATE_180
                    else -> 0
                }.also {
                    orientation = it
                }.takeIf { it != 0 }?.also {
                    exif.setAttribute(ExifInterface.TAG_ORIENTATION, it.toString())
                    exif.saveAttributes()
                }
            }?.run { action() }
        }
    }

    fun runTextRecognition(scanFile: File, activity: Activity) {
        if (!running) {
            running = true
            if (BuildConfig.FLAVOR.equals("extern")) {
                if (orientation == 0) {
                    viewModelScope.launch {
                        withContext(Dispatchers.Default) {
                            orientation = ExifInterface(scanFile.path).getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL)
                        }
                        runExternal(scanFile, activity)
                    }
                } else {
                    runExternal(scanFile, activity)
                }
            } else {
                viewModelScope.launch {
                    result.postValue(runCatching { ocrFeature.runTextRecognition(scanFile, activity) })
                }
            }
        }
    }

    private fun runExternal(scanFile: File, activity: Activity) {
        activity.startActivityForResult(
                Intent(ACTION).apply {
                    putExtra("orientation", when (orientation) {
                        ExifInterface.ORIENTATION_NORMAL -> 0
                        ExifInterface.ORIENTATION_ROTATE_90 -> 90
                        ExifInterface.ORIENTATION_ROTATE_180 -> 180
                        ExifInterface.ORIENTATION_ROTATE_270 -> 270
                        else -> 0
                    })
                    setDataAndType(AppDirHelper.ensureContentUri(Uri.fromFile(scanFile)), MIME_TYPE)
                    setFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
                }, OCR_REQUEST)
    }

    fun handleData(intent: Intent) {
        viewModelScope.launch {
            result.postValue(runCatching { ocrFeature.handleData(intent) })
        }
    }
}