Android 类型不匹配：推断的类型为（）->；单位，但运行！预料之中

我是Kotlin的新手，我正在尝试使用MLKit和CameraX库构建一个使用机器学习和对象检测的android摄像头应用程序

我的CameraActivity.kt文件中有以下代码，但我收到以下错误（代码中注释的位置）：

“类型不匹配：推断的类型为（）->单位，但可运行！应为”//ERROR 1

“类型不匹配：推断的类型为（？？？）->单位，但应为ImageAnalysis.Analyzer”//ERROR 2

谢谢你的帮助

import android.annotation.SuppressLint
import android.os.Bundle
import android.util.Log
import android.util.Size
import androidx.appcompat.app.AppCompatActivity
import androidx.camera.core.CameraSelector
import androidx.camera.core.ImageAnalysis
import androidx.camera.core.Preview
import androidx.camera.core.UseCase
import androidx.camera.lifecycle.ProcessCameraProvider
import androidx.camera.view.video.Metadata.builder
import androidx.core.content.ContextCompat
import androidx.databinding.DataBindingUtil
import androidx.lifecycle.LifecycleOwner
import com.example.gapt.databinding.ActivityCameraBinding
import com.example.gapt.utils.Draw
import com.google.common.util.concurrent.ListenableFuture
import com.google.mlkit.common.model.LocalModel
import com.google.mlkit.vision.common.InputImage
import com.google.mlkit.vision.objects.ObjectDetection
import com.google.mlkit.vision.objects.ObjectDetector
import com.google.mlkit.vision.objects.custom.CustomObjectDetectorOptions
import java.util.concurrent.Executor
import java.util.stream.DoubleStream.builder

class CameraActivity : AppCompatActivity() {

    private lateinit var binding: ActivityCameraBinding

    private lateinit var objectDetector: ObjectDetector
    private lateinit var cameraProviderFuture: ListenableFuture<ProcessCameraProvider>

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = DataBindingUtil.setContentView(this, R.layout.activity_camera)

        cameraProviderFuture = ProcessCameraProvider.getInstance(this)

        //ERROR 1
        cameraProviderFuture.addListener({val cameraProvider = cameraProviderFuture.get()}, ContextCompat.getMainExecutor(this))

        val localModel = LocalModel.Builder()
            .setAbsoluteFilePath("object_detection.tflite")
            .build()

        val customObjectDetectorOptions = CustomObjectDetectorOptions.Builder(localModel)
            .setDetectorMode(CustomObjectDetectorOptions.STREAM_MODE)
            .enableClassification()
            .setClassificationConfidenceThreshold(0.5f)
            .setMaxPerObjectLabelCount(3)
            .build()

        objectDetector = ObjectDetection.getClient(customObjectDetectorOptions)

    }

    @SuppressLint("UnsafeExperimentalUsageError")
    private fun bindPreview(cameraProvider: ProcessCameraProvider){
        val preview = Preview.Builder().build()

        val cameraSelector = CameraSelector.Builder()
            .requireLensFacing(CameraSelector.LENS_FACING_BACK)
            .build()

        preview.setSurfaceProvider(binding.previewView.surfaceProvider)

        val imageAnalysis = ImageAnalysis.Builder()
            .setTargetResolution(Size(1280, 720))
            .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
            .build()
        
        //ERROR 2
        imageAnalysis.setAnalyzer(ContextCompat.getMainExecutor(this), { imageProxy ->

            val rotationDegrees = imageProxy.imageInfo.rotationDegrees
            val image = imageProxy.image

            if(image != null){
                val processImage = InputImage.fromMediaImage(image, rotationDegrees)

                objectDetector
                    .process(processImage)
                    .addOnSuccessListener { objects ->
                        for(i in objects) {

                            if(binding.parentLayout.childCount > 1)
                                binding.parentLayout.removeViewAt(1)

                            val element = Draw(context = this,
                                rect = i.boundingBox,
                                text = i.labels.firstOrNull()?.text ?: "Undefined")

                            binding.parentLayout.addView(element)
                        }

                        imageProxy.close()
                    }.addOnFailureListener{
                        Log.v("CameraActivty", "Error - ${it.message}")
                        imageProxy.close()
                    }
            }
        })

        cameraProvider.bindToLifecycle(this as LifecycleOwner, cameraSelector, imageAnalysis, preview)

    }
}

导入android.annotation.SuppressLint
导入android.os.Bundle
导入android.util.Log
导入android.util.Size
导入androidx.appcompat.app.appcompat活动
导入androidx.camera.core.CameraSelector
导入androidx.camera.core.ImageAnalysis
导入androidx.camera.core.Preview
导入androidx.camera.core.UseCase
导入androidx.camera.lifecycle.ProcessCameraProvider
导入androidx.camera.view.video.Metadata.builder
导入androidx.core.content.ContextCompat
导入androidx.databinding.DataBindingUtil
导入androidx.lifecycle.LifecycleOwner
导入com.example.gapt.databinding.ActivityCameraBinding
导入com.example.gapt.utils.Draw
导入com.google.common.util.concurrent.ListenableFuture
导入com.google.mlkit.common.model.LocalModel
导入com.google.mlkit.vision.common.InputImage
导入com.google.mlkit.vision.objects.ObjectDetection
导入com.google.mlkit.vision.objects.ObjectDetector
导入com.google.mlkit.vision.objects.custom.CustomObjectDetectorOptions
导入java.util.concurrent.Executor
导入java.util.stream.DoubleStream.builder
类CameraActivity:AppCompatActivity（）{
私有lateinit变量绑定：ActivityCameraBinding
私有lateinit变量objectDetector:objectDetector
私有lateinit var cameraProviderFuture:ListenableFuture
重写创建时的乐趣（savedInstanceState:Bundle？）{
super.onCreate（savedInstanceState）
binding=DataBindingUtil.setContentView（此，R.layout.activity\U摄像头）
cameraProviderFuture=ProcessCameraProvider.getInstance（此）
//错误1
cameraProviderFuture.addListener（{val cameraProvider=cameraProviderFuture.get（）}，ContextCompat.getMainExecutor（this））
val localModel=localModel.Builder（）
.setAbsoluteFilePath（“object_detection.tflite”）
.build（）
val customObjectDetectorOptions=customObjectDetectorOptions.Builder（localModel）
.setDetectorMode（CustomObjectDetectorOptions.STREAM_模式）
.enableClassification（）
.SetClassification信心阈值（0.5f）
.setMaxPerObjectLabelCount（3）
.build（）
objectDetector=ObjectDetection.getClient（customObjectDetectorOptions）
}
@SuppressLint（“UnsafeExperimentalUsageError”）
private fun bindPreview（cameraProvider:ProcessCameraProvider）{
val preview=preview.Builder（）.build（）
val cameraSelector=cameraSelector.Builder（）
.RequiremensFacing（摄像机选择器镜头面向后）
.build（）
preview.setSurfaceProvider（binding.previewView.surfaceProvider）
val imageAnalysis=imageAnalysis.Builder（）
.setTargetResolution（尺寸（1280720））
.SetbackPressureStragy（图像分析。策略\u仅保留\u最新）
.build（）
//错误2
setAnalyzer（ContextCompat.getMainExecutor（this），{imageProxy->
val rotationDegrees=imageProxy.imageInfo.rotationDegrees
val image=imageProxy.image
如果（图像！=null）{
val processImage=InputImage.fromMediaImage（图像，旋转度）
目标检测器
.process（processImage）
.addOnSuccessListener{objects->
用于（对象中的i）{
如果（binding.parentLayout.childCount>1）
binding.parentLayout.removeViewAt（1）
val元素=绘图（上下文=此，
rect=i.boundingBox，
text=i.labels.firstOrNull（）？.text:“未定义”）
binding.parentLayout.addView（元素）
}
imageProxy.close（）
}.addOnFailureListener{
Log.v（“CameraActivty”，“Error-${it.message}”）
imageProxy.close（）
}
}
})
cameraProvider.bindToLifecycle（作为生命周期所有者、cameraSelector、图像分析、预览）
}
}

对于第一个，我不明白它为什么会抱怨，但是您可以通过在第一个大括号前面加上

Runnable

，即

…addListener（Runnable{val cameraProvider…

来强制它将lambda视为可运行的，对于第二个，您需要第二个lambda参数（度）为了匹配该接口的签名，即，

。{imageProxy，degrees->

好的，第一个错误消失了，但是当我引入“degrees”时，即，

imageAnalysis.setAnalyzer（ContextCompat.getmainpecutor（this），{imageProxy，degrees->

我现在得到了以下错误：“类型不匹配：推断的类型是（？？，，？）->单位，但需要图像分析分析仪“奇怪的是，这是同一个问题。好像SAM转换根本不起作用。你可以做和第一个一样的事情，用

ImageAnalysis.Analyzer

预处理lambda。我也不明白错误的原因。我以前从未见过这种情况。但是如果用

Runnable

预处理第一个lambda，修复了第一个c例如，也许在第二个lambda之前加上

ImageAnalysis.Analyzer

可以解决第二个问题。这是您最近创建的项目吗？在Gradle文件中检查您的所有插件和依赖项是否都是最新的可能是值得的。