Hi guys another question, I am working on making a library work in KMM. Using Android library and Ios Library and trying to pipe them into a a common code. My question is how do you guys deal with platform specific things? for example, when Android context is needed to create an instance of a class while the same class in ios needs a ios specific thing? Is there a way to work around this? Thanks in advance 🤔

Hah! That's my question too 😟 Currently what I'm doing is declaring the relevant variables as "Any" in the common code and then casting them in the platform specific code. Not sure if that's the best approach, though.

Hmm… 🤔 I’m quite hesitant to do that. I hope there is a better way.

Why hesitant? And what alternative d'you think there might be? It's a genuine question. I also felt/feel slightly uncomfortable about it, but having thought a little (I'm no expert), I don't see a better way. Would love to hear if there is, though

I am actually leaning toward keeping the initialization of class/instances that requires platform specific code to be declared on each side of the platform instead and only pipe the common things in the common code, say for example “Configs” or the likes. But I’m really not sure as well.

Yes, I started thinking that way, but I want/need (?) to bring platform specific types into my core calculations, which pushed me in this direction

hmmm… I think I haven’t gotten to that point yet? Quite inexperience still I guess. But I am hoping typealiasing/interface declaration would help. I think we should wait of others opinion. They might have something in mind.

I usually favor platform-specific injection of platform-specific things. You can see that in KaMPKit where we bind a Context to the Android side of the Koin graph, which gets used in some of the other Android-specific dependencies. If you do it this way then the Context never needs to be part of the common API

That works using platform specific things for constructing other things... can it would work for storing platform specific things? A common class can't "expect" some things and define others, can it?

not via expect/actual keywords, but you can do something like

interface CommonFoo

with

AndroidFoo

and

IosFoo

implementations. If you initialize in platform code you can pass a Context to Android but just reference it as

CommonFoo

in common without knowing about Context.

Agree with Russell and above "I am actually leaning toward keeping the initialization of class/instances that requires platform specific code to be declared on each side of the platform". This is a common thing going back for years just on Android, in my view. You need that Context, but unless you do something like set a static global in Application.onCreate, getting the context is rough. So far, in general, I'd say the same issue isn't as common on iOS.

@russhwolf, I was just looking at

MultiplatformSettings

and if I understand it correctly this is exactly what you are doing in there as well. I am trying to copy your pattern 😄

Sounds complicated, but it's not so bad, and it's not unbounded. It's basically Android's

Context

that makes things weird. Anyway, need to publish some docs on our current "best practice" around this, but we see the same pattern over and over.

Yeah Multiplatform Settings was the first place I had to deal with this but the same things come up every time you set up something new

Sounds complicated, but it’s not so bad, and it’s not unbounded. It’s basically Android’s 

Context

 that makes things weird. Anyway, need to publish some docs on our current “best practice” around this, but we see the same pattern over and over.

@kpgalligan Looking forward for the post. Thank you very much! ❤️

SQLdelight? Platform-specific config. Write local files? Same. You can't avoid it, but you can use a repeatable pattern to make it manageable.

If you can think of it as a dependency injection problem and not a KMP-specific thing, it's easier to see how the patterns you're already used to from Android (or whatever else) can apply

f you can think of it as a dependency injection problem and not a KMP-specific thing, it’s easier to see how the patterns you’re already used to from Android (or whatever else) can apply

I am starting to realize that now.

If you're using something like Koin, you could bind the appId or any other common dependency to your dependency graph and then it's a

get()

call instead. YMMV on whether that makes the dependency graph hard to follow. If you want to handroll it, you could have a common function like

CustomDependencyContainer.getAppId()

that you delegate to. Probably not worth it for appId, but might be nice if it's some other more complex dependency that you don't want to define initialization logic for twice.

If you want to handroll it, you could have a common function like 

CustomDependencyContainer.getAppId()

 that you delegate to. Probably not worth it for appId, but might be nice if it’s some other more complex dependency that you don’t want to define initialization logic for twice.

This is interesting but wouldn’t that just replace:

// Android
val androidInstance = LibraryClass(context, get<CustomDependencyContainer>.getAppId())

// Ios
val iosInstance = LibraryClass(get<CustomDependencyContainer>.getAppId())

Did I understand it wrong?

I meant that if you weren't using Koin, you could define your own function. If you're using Koin then use

get()

I see. Yeah I totally understand. Thank you very much. ❤️

where code is available on one platform but not on the other

Example?

The analytics library (MoEngange) I am working on defines a function:

setUserNotificationCategories(...)

for iOS but doesn’t have this on the Android side. There are other definitions as well other than this.

Where do you need to call it? I'd say there are a few options. expect extension function, maybe.

For the usage, I have no idea yet. That is actually also one of the things I am thinking about. Where lets say, I add the analytics code on the common code, but there are also platform specific logs I have to do as well. How would it all be structured where all common is define but also the flexibility of adding platform specific logs. For the expect/actual approach, would I just not implement it on the android side? since no equivalent function would be available?

Yes or a no op Implementation it applicable.

Hi Guys, Thank you for all the inputs really really helpful. May I ask for another advice. I have a situation where I need a class to be available in common but they have platform specific implementation. If I just do:

// Common
expect class SomeClass

// Android
actual typealias SomeClass = SomeClassAndroid

// iOS
actual typealias SomeClass = SomeClassIos

but the problem is that I cannot access the properties/functions in the

SomeClass

when using it inside common…

// common
val someClass = SomeClass()
someClass.someFunction(...) // I don/t have this definition in common, ERROR!

I thought of two things to do. 1. Declare an interface

SomeClassInterface

, declare the properties and functions in this interface and create a platform specific implementation wrapping the original class:

// common
interface SomeClassInterface {
   fun someFunction(...)
}

// Android
class SomeAndroidWrapperClass : SomeClassInterface {
    private val someClass = SomeClassAndroid()

    override fun someFunction(...) {
         someClass.someFunction(...)
    }
}

// iOS
class SomeIosWrapperClass : SomeClassInterface {
    private val someClass = SomeClassIos()

    override fun someFunction(...) {
         someClass.someFunction(...)
    }
}

2. Another approach I thoguh of is to keep the original typealias and simply declare the functions/properties as expect extension functions

// Common
expect class SomeClass

expect fun SomeClass.someFunction(...)

// Android
actual typealias SomeClass = SomeClassAndroid

actual fun SomeClass.someFunction(...) = someFunction(...)

// iOS
actual typealias SomeClass = SomeClassIos

actual fun SomeClass.someFunction(...) = someFunction(...)

My Question is whether, there is a better approach than these two? or if there is none, which of the two approach would be better to go through with? Thanks in advance guys. Really appreciate all the help.

It’s a complicated question with no easy solution. The question is mainly: In which context are you and do you control all the classes? If it’s in the context of a library and you don’t own the `actual class`es, create a dedicated class and handle delegation to the platform types. The reason for this is simple: You have no control over the platform classes and when they for example add a property / function that conflicts with one of your declared ones, this will break your multiplatform code. If it’s your internal code, its up to your taste. I usually go with extension functions as it’s just easier to implement. For example here is our uuid:

public expect class UUID

@Serializer(forClass = UUID::class)
public object UUIDSerializer : KSerializer<UUID> {

  override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("com.yazio.shared.uuid.UUIDSerializer", PrimitiveKind.STRING)

  override fun serialize(encoder: Encoder, value: UUID) {
    encoder.encodeString(value.value)
  }

  override fun deserialize(decoder: Decoder): UUID {
    val stringValue = decoder.decodeString()
    return uuid(stringValue)
  }
}

/**
 * @throws [kotlin.IllegalArgumentException] if the value is no valid uuid
 */
public expect fun uuid(value: String): UUID

public expect val UUID.value: String

public expect fun randomUUID(): UUID

public expect fun String.asUUIDorNull(): UUID?