Write and deploy a Kotlin library compatible with Android and iOS

My previous article described how to create an application on Kotlin-Multiplatform, compatible with Android & iOS

My first experience with Kotlin Native

I used a Kotlin http library for all my network calls, named KTOR

This library has multiple platform-specific implementations

• NSUrlConnections for iOS : ktor-client-ios
• OkHttp for Android/JVM : ktor-client-okhttp
• Apache for JVM : ktor-client-apache

You can find all engines on the official website : https://ktor.io/clients/http-client/engines.html

I use to create a lot of Android libraries, often UI components like ShapeOfView, RuntimePermissions or ExpectAnim, but sometimes architectural libraries like Freezer or RxRetroJsoup

Sample of layout made with ShapeOfView

Some of my libraries are made in Kotlin, so imagine my enthousiaste when I learn that I can create a Kotlin library compatible with Android & iOS !

Kotlin Multiplatform Library

To not loose time trying to create a project that not capable of publishing its artifacts to Bintray, I decided to fork an existing kotlin-multiplatform project : https://github.com/Kotlin/kotlinx-io

For my first library, I decided to implement a simple Logger, which will uses Logcat on Android, and print on iOS. I will not implement the JVM version, either the JS on my libraries, I will only focus on these 2 mobile platforms.

You can find the source code of my kotlin multiplatform on Github :

florent37/Multiplatform-Log

My project contains 2 sub modules : multiplatform-log-android & multiplatform-log-ios

The common source code is present inside the src/ module, and the name of the module determines the configuration of the project

Platform-Specific Declarations : Expect / Actual

Platform-Specific Declarations - Kotlin Programming Language

Kotlin MultiPlatform introduced the concept of Platform-Specific Declarations, providing a mechanism of expected and actual declarations :

With this mechanism, a common module can define expected declarations, and a platform module can provide actual declarations corresponding to the expected ones.

Here’s the code of PlatformLogger, present on my common module :

I created an actual PlatformLogger on each sub module : Android & iOS

Each method declared in the expect class (from the common module), has to be implemented as an actual fun on each actual implementation :

Actual implementations of PlatformLogger

Each sub-module defines a build.gradle, containing a dependency to the common module, specified with expectedBy, telling kotlin to use this module for actual implementations, created on the common module :

build.gradle for sub-modules (ios / android)

Generate libraries from sources

Next step, compile our source code to produce a library, compatible with gradle, which you can import using :

implementation "com.github.florent37:multiplatform-log:1.0.0"

First step : compile our code & produce libraries, just run :

./gradlew build publishToMavenLocal

This will produce an .aar file for android, and some .klib for ios, to resolve which .klib gradle should download, depending of the ios build configuration (eg: ios_x64, ios_arm64), its generates module.json files with pom-default.xml

Here an overview of a generated main/module.json :

Publish libraries to Bintray

First define a pom config, you can find mine pom.gradle file : https://github.com/florent37/Multiplatform-Log/blob/master/pom.gradle

Describe your bintray configuration used by the com.jfrog.bintray plugin (on my project, it’s inside gradle/bintray.gradle) :

bintray {
    user = System.getenv('BINTRAY_USER')
    key = System.getenv('BINTRAY_API_KEY')
    publish = true
    override = true
    pkg {
        userOrg = 'florent37'
        //the name of your bintray's maven repo
        repo = 'maven' 
        //the name of your bintray's repo        
        name = 'multiplatform-log'  
        licenses = ['Apache-2.0']
        publications = ['mavenProject']
        version {
            name = project.version
            released = new Date()
            vcsTag = project.version
        }
    }
}
bintrayUpload.doFirst {
    publications = project.publishing.publications
}

Then configure each project, to be able to generate its artifacts, depending on its platforms :

• aar on android
• jar on common
• klib + module.json on native

configure(allprojects) {
    apply from: rootProject.file('pom.gradle')
    apply from: rootProject.file('gradle/bintray.gradle')

    publishing {
        publications {
            mavenProject(MavenPublication) {
                if (!project.name.endsWith('ios') && !project.name.endsWith('android')) {
                    from components.java
                }

                groupId project.group
                artifactId project.name
                version project.version

                if (project.name.endsWith('android')) {
                    artifact("$buildDir/outputs/aar/${project.name}-debug.aar")
                }
                artifact sourceJar

                artifact emptyJar {
                    classifier 'javadoc'
                }

                withPom(pom)
            }
        }
    }

    afterReleaseBuild.dependsOn bintrayUpload
}

Finally, run bintrayUpload to send your artifacts on bintay :

./gradlew bintrayUpload

You can now import those libraries on another project :

Conclusion

Kotlin Multiplatform is a is a leap forward in our ways of developing mobile apps. We can now create a single source code, and import it on both platform.

It’s now possible to publish it on bintray, we can wrap almost all of components of each platform, and create a single multiplatform library.

It’s easy to include others dependencies on our android module (eg: okhttp), but it’s more complicated to use ios dependencies from CocoaPods as AlamoFire. For example we can not easily create a kotlin-multiplatform wrapper for Firebase 😣

You can find below the source code of the library “Multiplatform-Log” I described in this article, and some of my Kotlin-Multiplatform libraries, don’t hesitate to send me some pull requests !

florent37/Multiplatform-Log

florent37/Multiplatform-Bus

florent37/Multiplatform-LiveData

florent37/Multiplatform-Preferences