publishAllPublicationsToArtifactoryRepository UP-TO-DATE

MetalEngine.def

language = Objective-C
modules = MetalEngine
package = MetalEngine

iosTarget("ios") {
        binaries {
            framework {
                baseName = "shared"
            }
        }

        compilations.getByName("main") {
            val MetalEngine by cinterops.creating {
                defFile("src/nativeInterop/cinterop/MetalEngine.def")
                compilerOpts("-framework", "MetalEngine", "-F/shared/src/MetalEngine.xcframework")
            }
        }

        binaries.all {
            linkerOpts("-framework", "MetalEngine", "-F/shared/src/MetalEngine.xcframework")
        }
    }

fatal error: module 'MetalEngine' not found

noCompress

@RunWith(RobolectricTestRunner::class)

class MyTest {
    lateinit var interpreter: Interpreter

    @Before
    fun setUp() {
        val context = InstrumentationRegistry.getInstrumentation().targetContext
        val tfliteModel = FileUtil.loadMappedFile(context, "model.tflite")
        interpreter = Interpreter(tfliteModel)
    }

java.io.FileNotFoundException: This file can not be opened as a file descriptor; it is probably compressed

android{}

aaptOptions {
        noCompress("tflite")
    }

org.jetbrains.kotlinx

io.ktor

Uncaught Kotlin exception: kotlin.Throwable: The process was terminated due to the unhandled exception thrown in the coroutine [StandaloneCoroutine{Cancelling}@2929dd8, MainDispatcher]: mutation attempt of frozen kotlin.collections.HashMap@3b0368

val newPhotoSourceSyncInfo = mutableMapOf<PhotoSource, SyncInfo>()
newPhotoSourceSyncInfo.putAll(oldState.photoSourceSyncInfo)
newPhotoSourceSyncInfo[photoSource] = syncInfo

return oldState.copy(
    photoSourceSyncInfo = newPhotoSourceSyncInfo
)

val newPhotoSources = mutableListOf<PhotoSource>()
newPhotoSources.addAll(oldState.photoSources)

newPhotoSources.add(
    PhotoSource(
        id = 1
    )
)

return oldState.copy(
    photoSources = newPhotoSources,
)

val iosTarget: (String, KotlinNativeTarget.() -> Unit) -> KotlinNativeTarget =
        if (System.getenv("SDK_NAME")?.startsWith("iphoneos") == true)
            ::iosArm64
        else
            ::iosX64
    iosTarget("ios") {}

ios()

// MyClass is platform-specific
expect class MyClass(
  param1: Param1,
  param2: Param2,
  param3: Param3
) {
  // Builder is the same for all platforms
  class Builder {
     var param1: Param1? = null
     // ...

     fun build(): MyClass {
       return MyClass(
                param1 = param1 ?: defaultParam1,
                // ...
              )
     }
  }
}

commonTest

commonTest

private val scope = CoroutineScope(Dispatchers.Default)

class PhotoSyncService {

    private var jobMap: MutableMap<PhotoSource, Job> = mutableMapOf()

    fun sync(photoSource: PhotoSource, updateSyncInfo: (SyncInfo) -> Unit) {

        val existingJob = jobMap[photoSource]

        if (existingJob != null && existingJob.isActive)
            return

        val job = scope.launch {

            try {

                updateSyncInfo(
                    SyncInfo(
                        log = "Starting...",
                        status = SyncStatus.SYNCING
                    )
                )

                delay(2500)

                updateSyncInfo(
                    SyncInfo(
                        log = "Sync done.",
                        status = SyncStatus.SYNCED
                    )
                )

            } catch (ex: CancellationException) {

                updateSyncInfo(
                    SyncInfo(
                        log = "Sync canceled.",
                        status = SyncStatus.ERROR
                    )
                )
            }
        }

        jobMap[photoSource] = job
    }

    fun cancelSync(photoSource: PhotoSource) {

        val job = jobMap[photoSource]

        job?.let {

            job.cancel()
            jobMap.remove(photoSource)
        }
    }
}

PhotoStore

private fun forceSync(
    oldState: PhotoState,
    photoSource: PhotoSource
): PhotoState {

    photoSyncService.sync(photoSource) { syncInfo ->

        /*
         * This update comes from an background coroutine.
         * So we need to bring it back to the main thread.
         */
        launch(Dispatchers.Main) {
            this@PhotoStore.dispatch(PhotoAction.SyncInfoUpdate(photoSource, syncInfo))
        }
    }

    return oldState
}

forceSync()

PhotoSyncService

updateSyncInfo

launch

PhotoSyncService

PhotoStore

jobMap[photoSource] = job

InvalidMutabilityException

publishToMavenLocal

jvm

js

ios

androidMain

:compileTestKotlinJs

Non-incremental compilation will be performed: UNKNOWN_CHANGES_IN_GRADLE_INPUTS

build/classes/kotlin/js

build/classes/kotlin/js/main

shared

val commonModule = module {
    single<HttpClient> { TmdbApi.createHttpClient() }
    single<TmdbApi> { TmdbApi(client = get()) }
}

fun initKoin() = startKoin {
    modules(CommonModule.module)
}

val tmdbApi: TmdbApi by inject()

CommonModuleKt.doInitKoin()

ContentView

publishSingleVariant("release")

No tasks available

iosMain

KotlinByteArray

KotlinByteArray.init(size:init:)

let hundredMB = 1024 * 1024 * 100

let bytes = KotlinByteArray(size: hundredMB) { _ in 5 }

kotlin.native.internal.GC.collect()

suspend

interface Loader {
    suspend fun fetch()
}

public class RemoteFeatureLoader : Loader {
    public func fetch(completionHandler: @escaping (KotlinUnit?, Error?) -> Void) {
        
        doAsyncStuff { [weak self] in
            completionHandler(KotlinUnit(), nil)
        }
    }
}

class CommonLoader() {
    override suspend fun fetch() {
        localFeatureLoader.fetch()
        remoteFeatureLoader.fetch()
    }
}

CommonLoader.fetch()

class CommonViewModel(
    private val scope: CoroutineScope,
    private val uiContext: CoroutineContext,
) : ViewModel {

    override fun startup() {
        scope.launch(context = uiContext) {
            loader.fetch()
        }
    }
}

loader.fetch()

remoteFeatureLoader.fetch()

Android Gradle plugin requires Java 11 to run. You are currently using Java 1.8.