org.jetbrains.kotlin.platform.native

kotlin-multiplatform

release

debug

release

debug

#include<stdio.h>
#include<CL/cl.h>

int main(void)
{
    cl_int err;
    cl_uint numPlatforms;

    err = clGetPlatformIDs(0, NULL, &numPlatforms);
    if (CL_SUCCESS == err)
        printf("\nDetected OpenCL platforms: %d", numPlatforms);
    else
        printf("\nError calling clGetPlatformIDs. Error code: %d", err);

    return 0;
}

fun main() {
    val numOfPlatforms: cl_uint = 0U
    val result = clGetPlatformIDs(0, null, cValuesOf(numOfPlatforms))
    if (CL_SUCCESS == result) {
        println("Detected OpenCL platforms: ${numOfPlatforms}")
    } else {
        println("Error calling clGetPlatformIDs. Error code: $result");
    }
}

fun main() {
    memScoped {
        val pointer = cValuesOf(0U).getPointer(memScope)
        val result = clGetPlatformIDs(0, null, pointer)
        if (CL_SUCCESS == result) {
            println("Detected OpenCL platforms: ${pointer[0]}")
        } else {
            println("Error calling clGetPlatformIDs. Error code: $result");
        }
    }
}

launch {
              val response = withContext(Dispatchers.Default) {
                val client = HttpClient { }
                val emptyBody = object  : OutgoingContent.NoContent() {
                  override val contentLength: Long = 0

                  override fun toString(): String = "EmptyContent"
                }
                client.get<String>(body = emptyBody, port = 0, block = {
                  url {
                    takeFrom("<https://api.basebeta.com>")
                    encodedPath = "/rankings"
                  }
                })
              }
              output.send(Action.RankingsLoadedAction(
                list = emptyList(),
                diffResult = KDiffUtil.calculateDiff(
                  MItemDiffHelper(
                    oldList = emptyList(),
                    newList = emptyList()
                  )
                ),
                fromNetwork = true
              ))
            }

kotlin.native.concurrent.InvalidMutabilityException: mutation attempt of frozen <http://io.ktor.utils.io|io.ktor.utils.io>.core.ByteReadPacket@1bb0698

io.ktor.client.features.HttpCallValidator.Companion

.freeze()

.freeze()

private suspend fun syncFromNewtork(url: String): Boolean = suspendCoroutine { continuation ->
    val knResponseCallback: KNSyncManagerResponseCallBack = freezeObject(KNSyncManagerResponseCallBack(continuation))

    knNetworkBridge.makePostRestRequest(url: url)
}

class KNSyncManagerResponseCallBack(private val continuation: Continuation<Boolean>): KNResponseCallback {
    override fun onSuccess(response: Any?) {
        continuation.resume(true)
    }

    override fun onError(errorResponse: Any?) {
        continuation.resume(false)
    }
}

dispatch_async(dispatch_get_main_queue()) { /* */ }

linkDebugFrameworkMacosX64

ld.lld: error: undefined symbol: SnowboyDetectConstructor
>>> referenced by Types.kt:162 (/mnt/agent/work/4d622a065c544371/Interop/Runtime/src/main/kotlin/kotlinx/cinterop/Types.kt:162)
>>>               /tmp/konan_temp7723188199372240336/result.o:(snowboy_SnowboyDetectConstructor_wrapper0)

kotlin.IllegalStateException: There is no event loop. Use runBlocking { ... } to start one.

GlobalScope.async { /* any code*/ }.await()

runBlocking

scope

./gradlew bundle

try

finally

try

-Xg0

isStatic = true

If rebuilding is performed on App Store side, then 

.dSYM

 of rebuilt dynamic framework seems discarded and not downloadable from App Store Connect. So in this case it may be required to make the framework static, e.g. with

kotlin.native.initRuntimeIfNeeded()

val ref = runOnBackgroundThread {
    while(threadIsAlive) {
        // do some work
        runOnUIThread {
            // refresh UI
        }
        sleep(100) // pause bg thread for 100ms
    }
}

// at some later point
ref.cancel() // stop thread

val job = GlobalScope.async {
    while(isActive) {
        // do some work
        launch(context = Dispatchers.Main) {
            // refresh UI
        }
        delay(100)
    }
}

// later
job.cancel()

illegal attempt to access non-shared <object>

AtomicRef

AtomicReference