Understanding the Limitations of Using Java in Kotlin Multiplatform Mobile (KMM)

Discover why you can't use Java sources in the common module of Kotlin Multiplatform Mobile, and learn about effective workarounds.
---

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: KMM with Java sources in common (shared) module

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Navigating the Restrictions of Kotlin Multiplatform Mobile (KMM) with Java Sources

In the realm of mobile app development, Kotlin Multiplatform Mobile (KMM) offers a compelling solution for sharing code across iOS and Android applications. However, a common question arises among developers: Why can't we use Java sources in the common module of KMM? This query digs into the heart of KMM's structure and its compatibility with Java, despite Kotlin being interoperable with it.

The Core of the Problem

At its essence, Kotlin Multiplatform Mobile has two distinct targets: Kotlin/JVM (for Android) and Kotlin/Native (for iOS). This separation leads to a significant challenge for developers who wish to share Java code across both platforms.

Why Can't We Use Java in Common Code?

While it's a well-known fact that Kotlin is 100% compatible with Java, the limitation comes from the Kotlin/Native compiler. Here are some key points to consider:

Common Code Requirement: In the common module, dependencies must be compatible with both the JVM and Native compilers. This often excludes Java libraries, as Kotlin/Native lacks the knowledge to interpret Java dependencies for iOS.

Platform-Specific Implementation: When developers try to integrate a Java dependency in the common code, the Kotlin/Native compiler cannot convert or execute that code for iOS platforms.

Workarounds for Using Java-like Functionality

While the direct use of Java code in the KMM common module isn't feasible, there are strategies to leverage Java libraries indirectly. Here’s how:

1. expect/actual Mechanism

One effective workaround involves utilizing Kotlin's expect/actual declarations. Here’s how it works:

Expect Declaration: In the common module, you use expect information to define a function or property without providing its implementation.

Actual Declaration: In platform-specific modules (Android or iOS), you provide the actual implementation that either uses Java or Kotlin/Native compatible code.

This strategic separation allows your iOS app to utilize the desired functionality without directly incorporating Java code into the common module.

2. Platform-Specific Libraries

If a specific Java library provides the functionality you need, consider the following:

Find an Alternative: Look for a Kotlin or pure Swift equivalent that fulfills the same role without the dependencies on Java.

Use Common Libraries: Use libraries designed for multiplatform compatibility. This will ensure that parts of your code can seamlessly run on both platforms.

Conclusion

Kotlin Multiplatform Mobile simplifies the process of sharing code between iOS and Android platforms, but it comes with certain limitations regarding the use of Java in the shared common module. Being aware of these constraints allows developers to plan their architecture effectively and utilize the expect/actual pattern to maintain code efficiency across platforms.

As you embark on developing your next KMM application, keep these principles in mind to maximize your potential for code reusability and maintain compatibility with both Android and iOS ecosystems. Embrace the challenge and adapt your strategies to make the most of Kotlin Multiplatform Mobile!