228 lines
8.3 KiB
Kotlin
228 lines
8.3 KiB
Kotlin
package cash.z.ecc.android.ui.scan
|
|
|
|
import android.content.Context
|
|
import android.content.pm.PackageManager
|
|
import android.os.Bundle
|
|
import android.util.DisplayMetrics
|
|
import android.view.LayoutInflater
|
|
import android.view.View
|
|
import androidx.camera.core.*
|
|
import androidx.camera.lifecycle.ProcessCameraProvider
|
|
import androidx.core.content.ContextCompat
|
|
import cash.z.ecc.android.R
|
|
import cash.z.ecc.android.databinding.FragmentScanBinding
|
|
import cash.z.ecc.android.di.viewmodel.activityViewModel
|
|
import cash.z.ecc.android.di.viewmodel.viewModel
|
|
import cash.z.ecc.android.ext.onClickNavBack
|
|
import cash.z.ecc.android.ext.onClickNavTo
|
|
import cash.z.ecc.android.feedback.Report
|
|
import cash.z.ecc.android.feedback.Report.Tap.SCAN_BACK
|
|
import cash.z.ecc.android.feedback.Report.Tap.SCAN_RECEIVE
|
|
import cash.z.ecc.android.sdk.ext.twig
|
|
import cash.z.ecc.android.ui.base.BaseFragment
|
|
import cash.z.ecc.android.ui.send.SendViewModel
|
|
import com.google.common.util.concurrent.ListenableFuture
|
|
import kotlinx.coroutines.launch
|
|
import java.util.concurrent.ExecutorService
|
|
import java.util.concurrent.Executors
|
|
|
|
class ScanFragment : BaseFragment<FragmentScanBinding>() {
|
|
override val screen = Report.Screen.SCAN
|
|
private val viewModel: ScanViewModel by viewModel()
|
|
|
|
private val sendViewModel: SendViewModel by activityViewModel()
|
|
|
|
private lateinit var cameraProviderFuture: ListenableFuture<ProcessCameraProvider>
|
|
|
|
private var cameraExecutor: ExecutorService? = null
|
|
|
|
override fun inflate(inflater: LayoutInflater): FragmentScanBinding =
|
|
FragmentScanBinding.inflate(inflater)
|
|
|
|
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
|
|
super.onViewCreated(view, savedInstanceState)
|
|
if (cameraExecutor != null) cameraExecutor?.shutdown()
|
|
cameraExecutor = Executors.newSingleThreadExecutor()
|
|
|
|
binding.buttonReceive.onClickNavTo(R.id.action_nav_scan_to_nav_receive) { tapped(SCAN_RECEIVE) }
|
|
binding.backButtonHitArea.onClickNavBack() { tapped(SCAN_BACK) }
|
|
}
|
|
|
|
override fun onActivityCreated(savedInstanceState: Bundle?) {
|
|
super.onActivityCreated(savedInstanceState)
|
|
if (!allPermissionsGranted()) getRuntimePermissions()
|
|
}
|
|
|
|
override fun onAttach(context: Context) {
|
|
super.onAttach(context)
|
|
cameraProviderFuture = ProcessCameraProvider.getInstance(context)
|
|
cameraProviderFuture.addListener(Runnable {
|
|
bindPreview(cameraProviderFuture.get())
|
|
}, ContextCompat.getMainExecutor(context))
|
|
}
|
|
|
|
override fun onDestroyView() {
|
|
super.onDestroyView()
|
|
cameraExecutor?.shutdown()
|
|
cameraExecutor = null
|
|
}
|
|
|
|
private fun bindPreview(cameraProvider: ProcessCameraProvider) {
|
|
// Most of the code here is adapted from: https://github.com/android/camera-samples/blob/master/CameraXBasic/app/src/main/java/com/android/example/cameraxbasic/fragments/CameraFragment.kt
|
|
// it's worth keeping tabs on that implementation because they keep making breaking changes to these APIs!
|
|
|
|
// Get screen metrics used to setup camera for full screen resolution
|
|
val metrics = DisplayMetrics().also { binding.preview.display.getRealMetrics(it) }
|
|
val screenAspectRatio = aspectRatio(metrics.widthPixels, metrics.heightPixels)
|
|
val rotation = binding.preview.display.rotation
|
|
|
|
val preview =
|
|
Preview.Builder().setTargetName("Preview").setTargetAspectRatio(screenAspectRatio)
|
|
.setTargetRotation(rotation).build()
|
|
|
|
val cameraSelector = CameraSelector.Builder()
|
|
.requireLensFacing(CameraSelector.LENS_FACING_BACK)
|
|
.build()
|
|
|
|
val imageAnalysis = ImageAnalysis.Builder().setTargetAspectRatio(screenAspectRatio)
|
|
.setTargetRotation(rotation)
|
|
.setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
|
|
.build()
|
|
|
|
imageAnalysis.setAnalyzer(cameraExecutor!!, QrAnalyzer { q, i ->
|
|
onQrScanned(q, i)
|
|
})
|
|
|
|
// Must unbind the use-cases before rebinding them
|
|
cameraProvider.unbindAll()
|
|
|
|
try {
|
|
cameraProvider.bindToLifecycle(this, cameraSelector, preview, imageAnalysis)
|
|
preview.setSurfaceProvider(binding.preview.createSurfaceProvider())
|
|
} catch (t: Throwable) {
|
|
// TODO: consider bubbling this up to the user
|
|
mainActivity?.feedback?.report(t)
|
|
twig("Error while opening the camera: $t")
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Adapted from: https://github.com/android/camera-samples/blob/master/CameraXBasic/app/src/main/java/com/android/example/cameraxbasic/fragments/CameraFragment.kt#L350
|
|
*/
|
|
private fun aspectRatio(width: Int, height: Int): Int {
|
|
val previewRatio = kotlin.math.max(width, height).toDouble() / kotlin.math.min(
|
|
width,
|
|
height
|
|
)
|
|
if (kotlin.math.abs(previewRatio - (4.0 / 3.0))
|
|
<= kotlin.math.abs(previewRatio - (16.0 / 9.0))) {
|
|
return AspectRatio.RATIO_4_3
|
|
}
|
|
return AspectRatio.RATIO_16_9
|
|
}
|
|
|
|
private fun onQrScanned(qrContent: String, image: ImageProxy) {
|
|
resumedScope.launch {
|
|
if (viewModel.isNotValid(qrContent)) image.close() // continue scanning
|
|
else {
|
|
sendViewModel.toAddress = qrContent
|
|
mainActivity?.safeNavigate(R.id.action_nav_scan_to_nav_send_address)
|
|
}
|
|
}
|
|
}
|
|
|
|
// private fun updateOverlay(detectedObjects: DetectedObjects) {
|
|
// if (detectedObjects.objects.isEmpty()) {
|
|
// return
|
|
// }
|
|
//
|
|
// overlay.setSize(detectedObjects.imageWidth, detectedObjects.imageHeight)
|
|
// val list = mutableListOf<BoxData>()
|
|
// for (obj in detectedObjects.objects) {
|
|
// val box = obj.boundingBox
|
|
// val name = "${categoryNames[obj.classificationCategory]}"
|
|
// val confidence =
|
|
// if (obj.classificationCategory != FirebaseVisionObject.CATEGORY_UNKNOWN) {
|
|
// val confidence: Int = obj.classificationConfidence!!.times(100).toInt()
|
|
// "$confidence%"
|
|
// } else {
|
|
// ""
|
|
// }
|
|
// list.add(BoxData("$name $confidence", box))
|
|
// }
|
|
// overlay.set(list)
|
|
// }
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
// Permissions
|
|
//
|
|
|
|
private val requiredPermissions: Array<String?>
|
|
get() {
|
|
return try {
|
|
val info = mainActivity?.packageManager
|
|
?.getPackageInfo(mainActivity?.packageName, PackageManager.GET_PERMISSIONS)
|
|
val ps = info?.requestedPermissions
|
|
if (ps != null && ps.isNotEmpty()) {
|
|
ps
|
|
} else {
|
|
arrayOfNulls(0)
|
|
}
|
|
} catch (e: Exception) {
|
|
arrayOfNulls(0)
|
|
}
|
|
}
|
|
|
|
private fun allPermissionsGranted(): Boolean {
|
|
for (permission in requiredPermissions) {
|
|
if (!isPermissionGranted(mainActivity!!, permission!!)) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
private fun getRuntimePermissions() {
|
|
val allNeededPermissions = arrayListOf<String>()
|
|
for (permission in requiredPermissions) {
|
|
if (!isPermissionGranted(mainActivity!!, permission!!)) {
|
|
allNeededPermissions.add(permission)
|
|
}
|
|
}
|
|
|
|
if (allNeededPermissions.isNotEmpty()) {
|
|
requestPermissions(allNeededPermissions.toTypedArray(), CAMERA_PERMISSION_REQUEST)
|
|
}
|
|
}
|
|
|
|
override fun onRequestPermissionsResult(
|
|
requestCode: Int,
|
|
permissions: Array<out String>,
|
|
grantResults: IntArray
|
|
) {
|
|
super.onRequestPermissionsResult(requestCode, permissions, grantResults)
|
|
if (allPermissionsGranted()) {
|
|
// view!!.postDelayed(
|
|
// {
|
|
// onStartCamera()
|
|
// },
|
|
// 2000L
|
|
// ) // TODO: remove this temp hack to sidestep crash when permissions were not available
|
|
}
|
|
}
|
|
|
|
companion object {
|
|
private const val CAMERA_PERMISSION_REQUEST = 1002
|
|
|
|
private fun isPermissionGranted(context: Context, permission: String): Boolean {
|
|
return ContextCompat.checkSelfPermission(context, permission) == PackageManager.PERMISSION_GRANTED
|
|
}
|
|
}
|
|
} |