Passing lambda instead of interface

问题:

I have created an interface:

interface ProgressListener {
    fun transferred(bytesUploaded: Long)
}

but can use it only as anonymous class, not lambda

dataManager.createAndSubmitSendIt(title, message,
object : ProgressListener {
    override fun transferred(bytesUploaded: Long) {
        System.out.println(bytesUploaded.toString())
    }
})

I think it should be a possibility to replace it by lambda:

dataManager.createAndSubmitSendIt(title, message, {System.out.println(it.toString())})

But I am getting error: Type mismatch; required - ProgressListener, found - () -> Unit?

What am I doing wrong?

回答1:

As @zsmb13 said, SAM conversions are only supported for Java interfaces.

You could create an extension function to make it work though:

// Assuming the type of dataManager is DataManager.
fun DataManager.createAndSubmitSendIt(title: String, 
                                      message: String, 
                                      progressListener: (Long) -> Unit) {
    createAndSubmitSendIt(title, message,
        object : ProgressListener {
            override fun transferred(bytesUploaded: Long) {
                progressListener(bytesUploaded)
            }
        })
}

回答2:

Kotlin only supports SAM conversions for Java interfaces.

... note that this feature works only for Java interop; since Kotlin has proper function types, automatic conversion of functions into implementations of Kotlin interfaces is unnecessary and therefore unsupported.

-- Official documentation

If you want to use a lambda in the parameter, make your function take a function parameter instead of an interface. (For now at least. Supporting SAM conversions for Kotlin interfaces is an ongoing discussion, it was one of the possible future features at the Kotlin 1.1 live stream.)

回答3:

A little late to the party: instead of making an interface, you let the compile create one by taking a function directly instead of an interface in your datamanager, like this:

fun createAndSubmitSendIt(title: String, message: String, transferred: (Long) -> Unit) {
    val answer = TODO("whatever you need to do")
    transferred(answer)
}

and then you just use it like how you want it! If I remember correctly, what the kotlin/jvm compiler do is the same as making an interface.

Hope it helps!

回答4:

Another solution would be by declaring a typealias, injecting it somewhere and invoking it. Here the example:

internal typealias WhateverListener = (String) -> Unit

and then we inject that typealias to our class:

class Gallery constructor(private val whateverListener: WhateverListener) {

    ...

    galleryItemClickListener.invoke("hello")

    ...
}

so we have our lambda:

val gallery = Gallery { appNavigator.openVideoPlayer(it) }

Credits to my colleague Joel Pedraza, who showed me the trick while trying to find a solution <3.