I’m calling a cinterop-generated function that requires a callback as an argument. I’m using

staticCFunction()

to pass in a custom callback, but the callback requires some boilerplate to handle the C types. Is it possible to ‘wrap’ this callback with one of my own, without breaking the ‘no references’ rule for

staticCFunction()

? What I want is something like this, but this fails because “kotlinx.cinterop.staticCFunction must take an unbound, non-capturing function or lambda, but captures at (…) callback”

fun main() {
  attachAudioMixedProcessor { samples, frames ->
    for (frame in 0 until frames.convert()) {
      val left = samples[frame * 2 + 0]
      val right = samples[frame * 2 + 1]

      // ...
    }
  }
}

fun attachAudioMixedProcessor(
  callback: (samples: CPointer<FloatVar>, frames: Int) -> Unit
) {
  // call the c-interop function
  AttachAudioMixedProcessor(staticCFunction { buffer: COpaquePointer?, frames: UInt ->
    val samples: CPointer<FloatVar> = buffer?.reinterpret() ?: return@staticCFunction
    callback(samples, frames.toInt())
  })
}

// generated C interop function
external fun AttachAudioMixedProcessor(processor: CPointer<CFunction<(COpaquePointer?, UInt) -> Unit>>?)

Are you in control of the original C function? or is it a function from a library? Many C libraries that are callback-based have some sort of provision for setting a

user_data

pointer when calling or configuring the callback, and then when calling the callback they will pass the original

user_data

as one of the arguments. This way when the callback function is called, you have a way of getting the context back from inside the "standalone" callback.

it’s the function of a library, here’s the header definitions:

void AttachAudioMixedProcessor(AudioCallback processor);
typedef void (*AudioCallback)(void *bufferData, unsigned int frames);

If you cannot pass any

user_data

I think your only option is to have some other outside

Object

or

fun

that you can access from inside the callback function.

those would have to be top-level objects or functions, right?

yes indeed, AFAIK they are not capturing and can be called from within staticCFunction

hmm, I think I see what you mean but I don’t think it really helps avoiding the boilerplate

from your first code sample

oh I see! Hmm….

yes indeed, that is the reason why lots of C callback-based libraries have that

user_data

pointer, so you have something to distinguish for who the callback was intended

ah, so they can put some sort of ID in the data and use that to fetch it from the global-static list?

indeed, and it doesn't even need to be a global-static list

I got it working! Thanks for your help and tips @vbsteven

Nice, how did you end up doing this?

haha I was afraid someone would ask that - it’s not easy to summarise

That makes sense, however you are attaching and detaching both time using a

staticCFunction

, I'm not sure if both of these invocations will resolve to the same pointer, so it could be that you are detaching a different function than the one you are attaching

ahh okay, I assumed I could only call

staticCFunction {}

when all the processors were added, and the function was ‘ready’

AFAIK using

staticCFunction

will make sure there is a C function defined that can be called from C code. It might be smart enough to resolve to the same pointer if the same kotlin function is passed in, but I'm not sure

this works well 👍

// must be a static singleton, required by `staticCFunction {}`
internal object AudioDeviceInitializerImpl : AudioDeviceInitializer {
  override fun attachAudioMixedProcessor(processor: AudioProcessor) {
    mixedAudioProcessors += processor
  }

  internal fun attach(): Unit = AttachAudioMixedProcessor(processAllStatic)
  internal fun detach(): Unit = DetachAudioMixedProcessor(processAllStatic)
}

// must be a package-level function, required by `staticCFunction {}`
private val mixedAudioProcessors = mutableListOf<AudioProcessor>()

// must be a package-level function, required by `staticCFunction {}`
private fun processAll(buffer: COpaquePointer?, frames: UInt) {  for (
processor in mixedAudioProcessors) {
    // ...
  }
}

/** static reference to [processAll] */
private val processAllStatic = staticCFunction(::processAll)