Securing your app screen is something common in sensitive mobile apps like banking apps for example

We will start preventing the screen shots , screen recording or sharing on both android and ios

let’s create our common code , start by creating a simple interface that enables the secure screen or disables it , nothing more

interface SekureSkreenManager {
    fun start()
    fun stop()
}

@Composable
expect fun rememberSekureSkreenManager(): SekureSkreenManager

On Android it’s very simple you just add the secure flag to your activity window WindowManager.LayoutParams.FLAG_SECURE,

class AndroidSekureSkreenManager(private val activity: Activity) : SekureSkreenManager {
    override fun start() {
        activity.window.setFlags(
            WindowManager.LayoutParams.FLAG_SECURE,
            WindowManager.LayoutParams.FLAG_SECURE
        )
    }

    override fun stop() {
        activity.window.clearFlags(WindowManager.LayoutParams.FLAG_SECURE)
    }
}

then let’s create the actual implmentation for it

@Composable
actual fun rememberSekureSkreenManager(): SekureSkreenManager {
    val activity = LocalActivity.current ?: error("Activity is not yet created")
    return remember(activity) { AndroidSekureSkreenManager(activity) }
}

now that’s all your app screens are secured protected from MediaProjection , screenshots and even Android does not take a sreenshot of it when sliding to see the recent apps ,

so Android Does it for you , but IOS no instead it tells and informs you of those events and lets you react on them and execute whatever code you want on each event related to those

so let’s first see what IOS tells you about screen recording or screenshots

for screen recording ios fires and event once user starts sharing or recording the screen then if you want to hide something you execute your code once this event is fired

so we can subscribe to that event from the NotificationCenter
using this event name UIScreenCapturedDidChangeNotification
then you can observe the UIscreen.isCaptured()

so i prefer to create a dedicated class for this Usecase

class IosScreenRecordingObserver(
    private val onRecordingChanged: (isRecording: Boolean) -> Unit
) {
    /**
     * keeping reference to the observer to be able to remove it if needed
     */
    private var observer: NSObjectProtocol? = null

    /**
     *adds an observer inside [NSNotificationCenter] under that event name [UIScreenCapturedDidChangeNotification]
     * [UIScreenCapturedDidChangeNotification] triggers when user captures screens changes
     */

    fun startObserving() {
        observer = NSNotificationCenter.defaultCenter.addObserverForName(
            name = UIScreenCapturedDidChangeNotification,
            `object` = null,
            queue = NSOperationQueue.mainQueue()
        ) {
            val isRecording = UIScreen.mainScreen.isCaptured()
            onRecordingChanged(isRecording)
        }
    }

    /**
     * removing the observer from [NSNotificationCenter] and clearing it's reference
     */
    fun stopObserving() {
        observer?.let { NSNotificationCenter.defaultCenter.removeObserver(it) }
        observer = null
    }
}

now we have a class that fires the onRecordingChanged: (isRecording: Boolean) -> Unit whenever the user changes screen capturing state

let’s think what else we might need to secure , ScreenShots , and RecentApp Snapshot

RecentApp ScreenShots is something we can easy guess it’s solution whenver app leaves foreground we need to secure our screen , which is something yet we can do using the NotificationCenter

by observing the app lifecycle , so let’s also create a dedicated class for this lifecycle observing usecase

class IosAppLifeCycleObserver(
    private val onResigned: () -> Unit,
    private val onResumed: () -> Unit
) {
    private val center by lazy { NSNotificationCenter.defaultCenter }

    /**
     * keeping reference to the observer to be able to remove it if needed
     * [resignedObserver] observing when app  pauses
     * [resumedObserver] observing when app enters foreground  and resumes
     * [backgroundObserver] observing when app enters background completely
     */
    private var resignedObserver: NSObjectProtocol? = null
    private var resumedObserver: NSObjectProtocol? = null

    private var backgroundObserver: NSObjectProtocol? = null

    fun startObserving() {
        setupResignedObserver()
        setupResumedObserver()
        setupBackgroundObserver()
    }

    /**
     *adds an observer inside [NSNotificationCenter] under that event name [UIApplicationWillResignActiveNotification]
     * [UIApplicationWillResignActiveNotification] triggers when app is not interactable
     */

    private fun setupResignedObserver() {
        resignedObserver = center.addObserverForName(
            name = UIApplicationWillResignActiveNotification,
            `object` = null,
            queue = NSOperationQueue.mainQueue()
        ) {
            onResigned()
        }
    }

    /**
     *adds an observer inside [NSNotificationCenter] under that event name [UIApplicationDidEnterBackgroundNotification]
     * [UIApplicationDidEnterBackgroundNotification] triggers when app is completely on background
     */
    private fun setupBackgroundObserver() {
        backgroundObserver = center.addObserverForName(
            name = UIApplicationDidEnterBackgroundNotification,
            `object` = null,
            queue = NSOperationQueue.mainQueue()
        ) { onResigned() }

    }

    /**
     *adds an observer inside [NSNotificationCenter] under that event name [UIApplicationDidBecomeActiveNotification]
     * [UIApplicationDidBecomeActiveNotification] triggers when app is completely on resume and interactable
     */
    private fun setupResumedObserver() {
        resumedObserver = center.addObserverForName(
            name = UIApplicationDidBecomeActiveNotification,
            `object` = null,
            queue = NSOperationQueue.mainQueue()
        ) {
            onResumed()
        }
    }

    /**
     * removing observers
     */
    fun stopObserving() {
        resumedObserver?.let { center.removeObserver(it) }
        resignedObserver?.let { center.removeObserver(it) }
    }
}

now we have a class fires callbacks whenever lifecycle changes

so now we secured our app screen when app is on recents or when app is being recorded or shared , 1 thing yet left is to secure it from screenshots for that ios does not give you any info but has another way to solve it , it let’s you wrap your ui components inside an already secured components that by design are secured from the screenshots , but it accepts UIViews from IOS but here is the thing , the whole compose app is still rendered and viewed inside an IOS ViewController so using the same idea we can wrap any composable inside IOS Secured View

@Composable
expect fun SekuredBox(  content : @Composable ()->Unit )

let’s start by ios at the end we will never do anything inside the android part

@Composable
actual fun SekuredBox(content: @Composable (() -> Unit)) {
    /**
     * nothing needs to be done in android side if applied
     * [WindowManager.LayoutParams.FLAG_SECURE]
     */
    content()
}

we will use the ios secure text field trick and add our composable as an inner child of it so it inherites it’s security and screen shots prevention ( it might be enough to use it only without our previous observers ) , but i wanted to be more defensive and to cover multiple usecases

@OptIn(ExperimentalForeignApi::class)
@Composable
actual fun SekuredBox(
    content: @Composable () -> Unit
) {
    UIKitView(
        modifier = Modifier.fillMaxSize(),
        factory = {
            /**
             * creating the secure text field [UIView]
             * [setSecureTextEntry] enables the security for it
             * with [UIColor.clearColor] to make it transparent
             */
            val textField = UITextField().apply {
                setSecureTextEntry(true)
                userInteractionEnabled = true
                backgroundColor = UIColor.clearColor
            }
            val composeUIViewController = ComposeUIViewController(content = content)
            val composeView = composeUIViewController.view

            /**
             *  Find the secure container subview referred as canvas
             */
            val canvas = textField.subviews.firstOrNull {
                it.toString().contains("Canvas")
            } as? UIView

            canvas?.let { secureContainer ->
                /**
                 *  [userInteractionEnabled] allowing the compose to be interactable
                 *  [addSubview] adding compose to the canvas as subview to be viewed
                 *  [UiView.translatesAutoresizingMaskIntoConstraints] making the view fill entire screen
                 */
                secureContainer.userInteractionEnabled = true
                secureContainer.addSubview(composeView)
                composeView.translatesAutoresizingMaskIntoConstraints = false
                /**
                 * applying constraints the composable with respect to the canvas to fully fit inside
                 */
                NSLayoutConstraint.activateConstraints(
                    listOf(
                        composeView.topAnchor.constraintEqualToAnchor(secureContainer.topAnchor),
                        composeView.bottomAnchor.constraintEqualToAnchor(secureContainer.bottomAnchor),
                        composeView.leadingAnchor.constraintEqualToAnchor(secureContainer.leadingAnchor),
                        composeView.trailingAnchor.constraintEqualToAnchor(secureContainer.trailingAnchor)
                    )
                )
            }

            textField
        },
        update = { _ -> }
    )
}

now we covered almost all cases we need to secure our screen , let’s put them all together

we will use this state holder to keep info of our screen state

object SekureSkreenState {
    private val _isEnabled = MutableStateFlow(false)
    val isEnabled = _isEnabled.asStateFlow()
    fun update(enable: Boolean) = _isEnabled.update { enable }
}

class IosSekureSkreenManager : SekureSkreenManager {
    private val lifecycleObserver = IosAppLifeCycleObserver(
        onResumed = { SekureSkreenState.update(enable = false) },
        onResigned = { SekureSkreenState.update(enable = true) },
    )

    private val recordingObserver = IosScreenRecordingObserver(
        onRecordingChanged = { isRecording ->
            SekureSkreenState.update(enable = isRecording)
        }
    )

    override fun start() {
        lifecycleObserver.startObserving()
        recordingObserver.startObserving()
    }

    override fun stop() {
        lifecycleObserver.stopObserving()
        recordingObserver.stopObserving()
    }
}

that’s all let’s create some example app and run and test

@Preview
fun App() {
    val manager = rememberSekureSkreenManager()
    LaunchedEffect(Unit) {
        manager.start()
    }
    val isEnabled by SekureSkreenState.isEnabled.collectAsStateWithLifecycle()
    MaterialTheme {
        Box(Modifier.fillMaxSize()) {
            SekuredBox {
                HomeScreen()
            }
            if (isEnabled) {
                BlackScreen()
            }
        }
    }
}

Source Code : https://github.com/mohaberabi/sekure-skreen

Mostly all the crash reporting sdks or platforms works the same way for each platform on Android they capture unhandled exception happens on JVM & Sends them to remote console the same way happens also in IOS any fatal error is thrown and unhandled on the native side it is recorded and sent to remote console

but what happens when the fatal comes from common code in Kotlin Multiplatform Project , it’s already captured and recorded if you are running on Android Device but it’s not the same if you are running on IOS device , yes the app crashes but even if you are using and setup firebase crashlytics or any other crash reporting platform it will not be able to capture it , here is why

kotlin native throws exception which in return making the ios runtime terminates the process so it might be normal termination from the crash reporting Point Of View

for that special scenario kotlin already has a solution for it inside the iosMain

setUnhandledExceptionHook { throwable ->
    NativeFatalCrashMapper.mapAndTerminateFatal(throwable)

The hook is invoked whenever there is an uncaught exception reaching the boundaries of the Kotlin world, i.e. top-level main(), worker boundary, or when Objective-C to Kotlin call not marked with @Throws throws an exception.

The hook is in full control of how to process an unhandled exception and proceed further

this one captures and catches the exception without terminating the app which is something we don’t want we usually want the app to crash in such cases so there is also

public external fun terminateWithUnhandledException(throwable: Throwable): Nothing

that will give you the Throwable and kills the process but all of those are kotlin types which most of crash reporting will not be able to record and send so instead we will not use the terminateWithUnhandledException()
instead we will catch the exception get whatever info we need it from then raise IOS Itself to capture the error and terminate the process this way we are not altering any native behaviour of the OS + keeping the same logic of the Crash reproting SDK

so inside iosMain let’s define some class that will carry our information we need to record in case if fatal thrown

@Serializable
internal data class NativeFatalErrorData(
    @SerialName("message") val message: String,
    @SerialName("stack_trace") val stackTrace: String,
    @SerialName("cause_domain") val causeDomain: String,
    @SerialName("cause_message") val causeMessage: String? = null,
    @SerialName("cause_stack_trace") val causeStackTrace: String? = null,
)

internal fun Throwable.toNativeFatalErrorData() = NativeFatalErrorData(
    message = message ?: "Unknown Error Message ",
    stackTrace = stackTraceToString(),
    causeDomain = "KMP.commonMain.UnhandledException",
    causeMessage = cause?.message,
    causeStackTrace = cause?.stackTraceToString()
)

we will need little swift code to just make the crash happens at it’s side

@objc public class  IosFatalCrashMapper : NSObject {
    
    
    private static let  ERROR_DOMAIN = "KMP.commonMain.UnhanldedException"
    
    private static  let ERROR_CODE = 1
    
    @objc public static func mapAndTerminateFatal(
        data : [String : Any ] = [:]
    ){
        
        let error = NSError(
                   domain: ERROR_DOMAIN,
                   code: ERROR_CODE,
                   userInfo: data
               )

        fatalError("\(ERROR_DOMAIN): \(error)")
        
    }
}

no we will need to invoke this function inside kotlin code in iosMain

  setUnhandledExceptionHook { throwable ->

then we will serialize the data inside of the Throwable map it to Swift Map
and we will call our kotlin code inside the ExceptionHook

for creating the def files for ios objective-c interop with kotlin i will use this great plugin

    id("io.github.ttypic.swiftklib") version "0.6.4"

object NativeFatalCrashMapper {
    private val internalJson = Json {
        prettyPrint = true
        explicitNulls = false
        ignoreUnknownKeys = true
        encodeDefaults = true
    }

    @OptIn(ExperimentalForeignApi::class)
    fun mapAndTerminateFatal(
        throwable: Throwable,
    ) {
        val data = throwable.toNativeFatalErrorData()
        val dataJson = internalJson.encodeToString(data)
        val map = mapOf<Any?, Any?>(
            "data" to dataJson,
        )
        IosFatalCrashMapper.mapAndTerminateFatalWithData(
            data = map
        )
    }
}

now for using Firebase Crashlytics itself i will use Kotlin Cocoapods
alias(libs.plugins.kotlinCocoapods)

    alias(libs.plugins.kotlinCocoapods)
    cocoapods {
        summary = ""
        homepage = "Analytics"
        version = "1.0"
        ios.deploymentTarget = "16.0"
        framework {
            baseName = "Analytics"
            isStatic = false
        }
        pod("FirebaseCrashlytics") {
            extraOpts += listOf("-compiler-option", "-fmodules")
        }
        pod("FirebaseAnalytics") {
            extraOpts += listOf("-compiler-option", "-fmodules")
        }
    }

that’s all what all we need now is to hook the error and see it in firebase , we can force crash to test

@OptIn(ExperimentalNativeApi::class, ExperimentalForeignApi::class)
private fun hookUnhandledCommonError() {
    setUnhandledExceptionHook { throwable ->
        NativeFatalCrashMapper.mapAndTerminateFatal(throwable)
    }
}

call it inside the MainViewController in iosMain compose code

fun MainViewController() =
    ComposeUIViewController(
        configure = {
            hookUnhandledCommonError()

Permission Handling in Kotlin Multiplatform (KMP) — A Real-World Architecture

Handling permissions in Kotlin Multiplatform (KMP) is one of those areas where naive abstractions break very quickly.

Because Android and iOS have fundamentally different permission models:

Android
Centralized permission
Runtime permission APIs
Can re-request (rationale)
Activity result based

IOS
Permission per domain
Each framework owns its permission
Callback / delegate based

let’s try to create a combined solution that works well for both of them allowing us to handle it in a scalable simple way , also let’s extend IOS to allow it to handle multiple permisions

Core Permission Model (commonMain)

sealed interface AppPermission {
    data object Notifications : AppPermission
    data object PickImage : AppPermission
    data object WriteToCalender : AppPermission
    data object ReadFromCalender : AppPermission
}

sealed interface AppPermissionStatus {
    data object Granted : AppPermissionStatus
    data object DeniedForever : AppPermissionStatus
    data object Requestable : AppPermissionStatus
}

/**
 *a simple helper for permission manager to be implemented on each platform
 */
interface PermissionManagerDelegate {
    /**
     *  checks the decision needed to be made by the app which in return requests the permission
     *  or grant execution or show blocked ui
     */
    suspend fun checkDecision(permission: AppPermission): AppPermissionStatus

    /**
     * checks if the required system service is guarded by permission or not
     */
    suspend fun requiresPermission(permission: AppPermission): Boolean

    /**
     * opens devices settings to control permission
     */
    suspend fun openAppDeviceSettings()

}

/**
 * controls app wide permission
 */
interface PermissionManager {
    /**
     * checks permission and request if needed and result are reacted upon them
     * inside the [rememberPermissionManager]
     * [onResponse] Callback
     */
    suspend fun checkAndRequestIfNeed(permission: AppPermission)

    /**
     * opens devices settings to control permission
     */
    suspend fun openDeviceSettings()

    /**
     * checks if permission is granted or not
     */
    suspend fun isGranted(permission: AppPermission): Boolean

    /**
     * checks if the required system service is guarded by permission or not
     */
    suspend fun isPermissionRequire(permission: AppPermission): Boolean

    /**
     * checks if we still can request permission again ,
     * it happens on android if rationale or never requested for example
     */
    suspend fun canBeRequestedAgain(permission: AppPermission): Boolean
}

@Composable

expect fun rememberPermissionManager(
    onResponse: (AppPermissionStatus) -> Unit,
): PermissionManager

internal class DefaultPermissionManager(
    private val delegate: PermissionManagerDelegate,
    private val onLaunch: suspend (AppPermission) -> Unit,
) : PermissionManager

Android Side

internal class AndroidPermissionManagerDelegate(
    private val activity: Activity,
) : PermissionManagerDelegate {
    /**
     * checks what should happen for the requested system service permissions
     * it returns [AppPermissionStatus.Granted] in case no need to request for permission
     * or the permission is already granted
     * returns [AppPermissionStatus.Requestable] if [Activity.shouldShowRequestPermissionRationale] returns true
     * else it returns [AppPermissionStatus.DeniedForever]
     */
    override suspend fun checkDecision(permission: AppPermission): AppPermissionStatus {
        if (requiresPermission(permission).not()) return AppPermissionStatus.Granted
        if (activity.permissionGranted(permission.toAndroid())) return AppPermissionStatus.Granted
        val rationale = activity.showPermissionRationale(permission.toAndroid())
        if (rationale) return AppPermissionStatus.Requestable
        return AppPermissionStatus.DeniedForever
    }

    /**
     *checks if the requested system service needs permission or not
     */

    override suspend fun requiresPermission(
        permission: AppPermission,
    ): Boolean = when (permission) {
        AppPermission.Notifications -> requireNotificationPermission()
        AppPermission.PickImage -> false
        AppPermission.WriteToCalender, AppPermission.ReadFromCalender -> true
    }

    /**
     * launching an intent for the [Settings.ACTION_APPLICATION_DETAILS_SETTINGS] for the caller app
     */
    override suspend fun openAppDeviceSettings() {
        val uri = Uri.fromParts("package", activity.packageName, null)
        val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS, uri)
            .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
        activity.startActivity(intent)
    }
}

/**
 * an extension for the [PermissionManager] that will use same impl but adds new functionality allowing
 * callers to request multiple permissions at once
 */
class AndroidMultiplePermissionManager(
    private val singlePermissionManager: PermissionManager,
    private val onLaunch: suspend (List<AppPermission>) -> Unit,
) : MultiplePermissionManager, PermissionManager by singlePermissionManager {
    override suspend fun requestMultiple(permissions: List<AppPermission>) {
        onLaunch(permissions)
    }
}

@Composable
actual fun rememberPermissionManager(
    onResponse: (AppPermissionStatus) -> Unit,
): PermissionManager {
    val activity = requireNotNull(LocalActivity.current) {
        "Activity is not yet attached"
    }
    val androidLauncher = rememberLauncherForActivityResult(
        contract = ActivityResultContracts.RequestPermission(),
    ) { granted ->
        if (granted) {
            onResponse(AppPermissionStatus.Granted)
        } else {
            onResponse(AppPermissionStatus.DeniedForever)
        }
    }

    val delegate = remember {
        AndroidPermissionManagerDelegate(activity = activity)
    }
    return remember(
        onResponse,
        androidLauncher,
        activity,
    ) {
        DefaultPermissionManager(
            delegate = delegate,
            onLaunch = {
                if (activity.showPermissionRationale(it.toAndroid())) {
                    onResponse(AppPermissionStatus.Requestable)
                } else {
                    androidLauncher.launch(input = it.toAndroid())
                }
            },
        )
    }
}

@Composable
actual fun rememberMultiplePermissionsManager(
    onResponse: (AppPermissionStatus) -> Unit,
    onMultipleResponse: (Map<AppPermission, AppPermissionStatus>) -> Unit,
): MultiplePermissionManager {
    val activity = requireNotNull(
        LocalActivity.current
    ) {
        "multiplePermissionsManager activity not yet attached or detached"
    }
    val singleLauncher = rememberPermissionManager(onResponse = onResponse)
    val multipleLauncher = rememberLauncherForActivityResult(
        contract = ActivityResultContracts.RequestMultiplePermissions(),
    ) { result ->
        val perms = result.map { (permission, granted) ->
            val status = if (activity.showPermissionRationale(permission)) {
                AppPermissionStatus.Requestable
            } else {
                if (granted) AppPermissionStatus.Granted else AppPermissionStatus.DeniedForever
            }
            permission.toAppPermission() to status
        }.toMap()
        onMultipleResponse(perms)
    }

    return remember(
        activity,
    ) {
        AndroidMultiplePermissionManager(
            onLaunch = {
                val android = it.map { perm -> perm.toAndroid() }.toTypedArray()
                multipleLauncher.launch(android)
            },
            singlePermissionManager = singleLauncher,
        )
    }

}

Now IOS Part , it is almost like android but the key idea is ios does not handle permissions like android where is a single place where permissions are handled , no instead each system domain has it’s own permission handling system so we need to isolate each part or each domain and find a centeralized way to make use of all of them

/**
 * as ios works differently than android regarding permissions it does not has this
 * centralized place for handling permissions instead each domain has it's own permission handling system
 * so as inspired from android this delegate will be used for any type of permissions needed and also
 * will be extended even for the multiple permissions
 */
interface SinglePermissionDelegate {
    suspend fun launch(): Boolean
    suspend fun checkDecision(): AppPermissionStatus
}

/**
 * checks the [SinglePermissionDelegate.checkDecision] and suspends until result
 * upon returned result we react upon , if we need to request , granted or denied
 */
internal suspend fun SinglePermissionDelegate.checkPermissionOrLaunch(): AppPermissionStatus {
    val status = checkDecision()
    return if (status == AppPermissionStatus.Requestable) {
        val granted = launch()
        if (granted) AppPermissionStatus.Granted
        else AppPermissionStatus.DeniedForever
    } else {
        status
    }
}

/**
 * launches and or requests the permission for Reading Gallery Images
 */
class ReadImagePermissionDelegate : SinglePermissionDelegate {
    private val accessReadWrite = PHAccessLevelReadWrite

    override suspend fun launch(): Boolean {
        return suspendOnMain { resume ->
            PHPhotoLibrary.requestAuthorizationForAccessLevel(accessLevel = accessReadWrite) { status ->
                val granted = when (status) {
                    PHAuthorizationStatusAuthorized,
                    PHAuthorizationStatusLimited -> true

                    else -> false
                }
                resume(granted)
            }

        }
    }

    override suspend fun checkDecision(): AppPermissionStatus {

        val status = PHPhotoLibrary.authorizationStatusForAccessLevel(accessReadWrite)
        return when (status) {
            PHAuthorizationStatusAuthorized,
            PHAuthorizationStatusLimited -> AppPermissionStatus.Granted

            PHAuthorizationStatusNotDetermined -> AppPermissionStatus.Requestable
            PHAuthorizationStatusDenied,
            PHAuthorizationStatusRestricted -> AppPermissionStatus.DeniedForever

            else -> AppPermissionStatus.DeniedForever
        }
    }


}

/**
 * launches and or requests the permission for Reading Reminders or Calender
 */

class ReminderPermissionDelegate() : SinglePermissionDelegate {
    override suspend fun launch(): Boolean {
        return suspendOnMain { resume ->
            val store = EKEventStore()
            store.requestAccessToEntityType(
                entityType = EKEntityType.EKEntityTypeReminder,
            ) { granted, error ->
                resume(granted)
            }
        }
    }

    override suspend fun checkDecision(): AppPermissionStatus {
        val status = EKEventStore.Companion
            .authorizationStatusForEntityType(entityType = EKEntityType.EKEntityTypeReminder)
        return when (status) {
            EKAuthorizationStatusAuthorized -> AppPermissionStatus.Granted
            EKAuthorizationStatusNotDetermined -> AppPermissionStatus.Requestable
            else -> AppPermissionStatus.DeniedForever
        }
    }


}

class IosPermissionManagerDelegate(
    private val reminderLauncher: ReminderPermissionDelegate,
    private val imageDelegate: ReadImagePermissionDelegate,
    private val notificationsPermissionDelegate: NotificationsPermissionDelegate
) : PermissionManagerDelegate {
    /**
     * checks what should happen for the requested system service permissions
     * and returns the [AppPermissionStatus] from each permission Delegate for the requested [AppPermission]
     */
    override suspend fun checkDecision(permission: AppPermission): AppPermissionStatus {
        return when (permission) {
            AppPermission.Notifications -> notificationsPermissionDelegate.checkDecision()
            AppPermission.PickImage -> imageDelegate.checkDecision()
            AppPermission.ReadFromCalender,
            AppPermission.WriteToCalender -> reminderLauncher.checkDecision()
        }
    }

    /**
     *checks if the requested system service needs permission or not
     */
    override suspend fun requiresPermission(permission: AppPermission): Boolean = true

    /**
     * launching an [NSURL] for the [UIApplicationOpenSettingsURLString]
     */
    override suspend fun openAppDeviceSettings() = suspendCancellableCoroutine { continuation ->
        val url = NSURL(string = UIApplicationOpenSettingsURLString)
        UIApplication.sharedApplication.openURL(
            url = url,
            options = mapOf<Any?, Any?>(),
            completionHandler = {},
        )
        continuation.resume(Unit)
    }

}

/**
 * A Facade  that wraps each [SinglePermissionDelegate] for each [AppPermission] and launches the request dialogue
 * then invokes the result inside [onResponse]
 */
class IosPermissionLauncher(
    private val onResponse: (granted: Boolean) -> Unit,
    private val reminderPermissionDelegate: ReminderPermissionDelegate,
    private val imagePermissionDelegate: ReadImagePermissionDelegate,
    private val notificationsPermissionDelegate: NotificationsPermissionDelegate
) {


    suspend fun launch(permission: AppPermission) {
        val granted = when (permission) {
            AppPermission.Notifications -> notificationsPermissionDelegate.launch()
            AppPermission.PickImage -> imagePermissionDelegate.launch()
            AppPermission.ReadFromCalender -> reminderPermissionDelegate.launch()
            AppPermission.WriteToCalender -> reminderPermissionDelegate.launch()

        }
        onResponse(granted)
    }
}



class IosMultiplePermissionManager(
    private val onLaunch: suspend (permissions: List<AppPermission>) -> Unit,
    private val permissionManager: PermissionManager
) : MultiplePermissionManager, PermissionManager by permissionManager {
    override suspend fun requestMultiple(permissions: List<AppPermission>) {
        onLaunch(permissions)
    }
}

/**
 * ios needs all of permission dialogue to be used inside the Main Thread , as a
 * way of being more defensive added this function to make use of coroutine
 * that will suspend with a lambda to be used to request permissions for any area in the IOS System
 */
internal suspend inline fun <T> suspendOnMain(
    crossinline block: (resume: (T) -> Unit) -> Unit
) = suspendCancellableCoroutine { continuation ->
    dispatch_async(queue = dispatch_get_main_queue()) {
        block { value ->
            if (continuation.isActive) {
                continuation.resume(value)
            }
        }
    }

}

/**
 * acts a dependency container for reusability for all type of permissions inside ios
 * any new permission needed to be supported should be also added here
 */
internal data class SinglePermissionDelegates(
    val reminder: ReminderPermissionDelegate = ReminderPermissionDelegate(),
    val image: ReadImagePermissionDelegate = ReadImagePermissionDelegate(),
    val notifications: NotificationsPermissionDelegate = NotificationsPermissionDelegate(),
)

internal object SinglePermissionDelegateDefaults {
    val delegates by lazy {
        SinglePermissionDelegates()
    }
}

@Composable
internal fun rememberPermissionDelegate(
    delegates: SinglePermissionDelegates = SinglePermissionDelegateDefaults.delegates
) = remember(
    delegates
) {
    IosPermissionManagerDelegate(
        reminderLauncher = delegates.reminder,
        imageDelegate = delegates.image,
        notificationsPermissionDelegate = delegates.notifications
    )
}

@Composable
actual fun rememberPermissionManager(
    onResponse: (AppPermissionStatus) -> Unit,
): PermissionManager {

    val delegate = rememberPermissionDelegate()

    val launcher = remember {
        IosPermissionLauncher(
            reminderPermissionDelegate = SinglePermissionDelegateDefaults.delegates.reminder,
            imagePermissionDelegate = SinglePermissionDelegateDefaults.delegates.image,
            notificationsPermissionDelegate = SinglePermissionDelegateDefaults.delegates.notifications,
            onResponse = { granted ->
                if (granted) {
                    onResponse(AppPermissionStatus.Granted)
                } else {
                    onResponse(AppPermissionStatus.DeniedForever)
                }
            },
        )
    }
    return remember() {
        DefaultPermissionManager(
            delegate = delegate,
            onLaunch = {
                launcher.launch(it)
            },
        )
    }
}

@Composable
actual fun rememberMultiplePermissionsManager(
    onResponse: (AppPermissionStatus) -> Unit,
    onMultipleResponse: (Map<AppPermission, AppPermissionStatus>) -> Unit,
): MultiplePermissionManager {


    val multipleLauncher = remember {
        IosMultiplePermissionLauncher(
            reminderPermissionDelegate = SinglePermissionDelegateDefaults.delegates.reminder,
            readImagePermissionDelegate = SinglePermissionDelegateDefaults.delegates.image,
            notificationsPermissionDelegate = SinglePermissionDelegateDefaults.delegates.notifications,
        )
    }

    val manager = rememberPermissionManager(
        onResponse = onResponse
    )
    return remember {
        IosMultiplePermissionManager(
            onLaunch = {
                val result = multipleLauncher.launchMultiple(permissions = it)
                onMultipleResponse(result)
            },
            permissionManager = manager
        )
    }

}

that’s it , now let’s add some functionality to observe the permissions based on the lifecycle change of the app and add some ui part to test it

each time app returns to foreground we will check the permission and react upon them

/**
 * Simple [Composable] that observers the app lifecycle and mutates the Permission Status each time
 * the user changes app lifecycle to always have the latest permission status from the device settings
 */
@Composable
fun rememberPermissionWithLifeCycle(
    vararg permission: AppPermission,
    onRequested: (Map<AppPermission, AppPermissionStatus>) -> Unit = {},
): Boolean {
    var isGranted by rememberSaveable {
        mutableStateOf(false)
    }
    var shouldRequestAgain by rememberSaveable {
        mutableStateOf(false)
    }
    val permissionManager = rememberMultiplePermissionsManager { resultMap ->
        val allGranted = resultMap.values.all { it == AppPermissionStatus.Granted }
        onRequested(resultMap)
        isGranted = allGranted
    }
    LaunchedEffect(
        Unit,
    ) {
        permissionManager.requestMultiple(permission.toList())
    }

    LaunchedEffect(
        shouldRequestAgain,
    ) {
        if (shouldRequestAgain) {
            permissionManager.requestMultiple(permission.toList())
            shouldRequestAgain = false
        }
    }
    ComposeLifeCycleObserver { event ->
        when (event) {
            Lifecycle.Event.ON_RESUME -> shouldRequestAgain = true
            else -> Unit
        }
    }
    return isGranted
}

@Composable
fun ComposeLifeCycleObserver(
    onLifeCycleEvent: (Lifecycle.Event) -> Unit,
) {
    val lifecycleOwner = LocalLifecycleOwner.current
    DisposableEffect(lifecycleOwner) {
        val observer = LifecycleEventObserver { _, event ->
            onLifeCycleEvent(event)
        }
        lifecycleOwner.lifecycle.addObserver(observer)
        onDispose { lifecycleOwner.lifecycle.removeObserver(observer) }
    }

}

now let’s add some ui to test the
don’t forget to handle the AndroidManifest.xml and Info.Plist

fun App() {
    MaterialTheme {
        var permissions by remember {
            mutableStateOf(mapOf<AppPermission, AppPermissionStatus>())
        }
        val areAllGranted = rememberPermissionWithLifeCycle(
            AppPermission.Notifications,
            AppPermission.ReadFromCalender,
            AppPermission.WriteToCalender,
            onRequested = {
                permissions = it
            }
        )

        Scaffold { padding ->
            Column(

                modifier = Modifier.fillMaxSize()
                    .padding(padding)
                    .padding(20.dp)
            ) {

                permissions.forEach {
                    val name = when (it.key) {
                        AppPermission.Notifications -> "Notifications"
                        AppPermission.PickImage -> "Pick Image"
                        AppPermission.ReadFromCalender -> "Read Calender"
                        AppPermission.WriteToCalender -> "Write Calender"
                    }
                    val value = when (it.value) {
                        AppPermissionStatus.DeniedForever -> "Denied Forever "
                        AppPermissionStatus.Granted -> "Granted"
                        AppPermissionStatus.Requestable -> "Requestable"
                    }
                    Row(
                        modifier = Modifier.fillMaxWidth().padding(8.dp),
                        horizontalArrangement = Arrangement.SpaceAround
                    ) {
                        Text(name)
                        Text(value)
                    }
                }
            }
        }
    }
}

source code : https://github.com/mohaberabi/konsent

You’re using a modern mocking library (like Mokkery) . You’re trying to mock real production classes. but Kotlin makes everything final by default.

The idea is simple it’s built on top of the Kotlin Compiler Plugins that gives you some Extensions on the Frontend “FIR” Frontend Intermediate Representations that offers multiple hooks or functions that you can listen to and react upon , For Example to make the Classes , Functions , Members of a Final class all Are Open

And here is the thing Kotlin is A Multiplatform Language so anything you do with the compiler is multiplatform as well and can work for any target or platform

My usecase here is to try to mock final classes in A Compose Multiplatform App (IOS & Android )

Creating the compiler plugin module

we will only need the compiler.embeddable dependency
which will give us access to the FIR Extensions we need and to include the
Java Library Plugin so we can create the Jar file which we can provide to the compiler args

plugins {
    kotlin("jvm")
    `java-library`
}

group = "org.mohaberabi.make-open"
version = "1.0.0"


dependencies {
    testImplementation(kotlin("test"))
    implementation(libs.kotlin.compiler.embeddable)
// org.jetbrains.kotlin:kotlin-compiler-embeddable:<kotlin>
}

tasks.test {
    useJUnitPlatform()
}
kotlin {
    jvmToolchain(21)
}

then we need to extend and create the CompilerPluginRegistrar

This class is the bridge between our plugin code and the Kotlin compiler itself.

inside the main/koltin

@OptIn(ExperimentalCompilerApi::class)
class AllOpenComponentRegistrar : CompilerPluginRegistrar() {
    override val supportsK2: Boolean
        get() = true

    @OptIn(ExperimentalCompilerApi::class)
    override fun ExtensionStorage.registerExtensions(
        configuration: CompilerConfiguration
    ) {

        FirExtensionRegistrarAdapter.registerExtension(FirAllOpenExtensionRegistrar())
    }
}

by extending the CompilerPluginRegistrar you set your class as CompilerPlugin then we override the supportsK2 to make it enabled for the K2 Compiler as it is not enabled by default even the K1 is deprecated

then inside the registerExtensions() , you pass your extension and modification which you want to attach to compiler

class FirAllOpenExtensionRegistrar : FirExtensionRegistrar() {
    override fun ExtensionRegistrarContext.configurePlugin() {
        +::FirAllOpenStatusTransformer
    }
}

class FirAllOpenStatusTransformer(
    session: FirSession
) : FirStatusTransformerExtension(session) {
    override fun needTransformStatus(
        declaration: FirDeclaration
    ): Boolean = when (declaration) {
        is FirRegularClass,
        is FirSimpleFunction,
        is FirProperty -> true

        else -> false
    }

    override fun transformStatus(
        status: FirDeclarationStatus,
        declaration: FirDeclaration
    ): FirDeclarationStatus = when (declaration) {
        is FirRegularClass,
        is FirSimpleFunction,
        is FirProperty ->
            status.transform(modality = Modality.OPEN)

        else -> status
    }
}

now your transformer class is where you write the code to attach a modification to the compiler
needTransformStatus() : returns wether we need to transform or not , for now we will transform only Classes , Functions , Properties
then transformStatus(): applies the transformation if declaration is one of them

then we add our Transform to Extensions
now we need to attach the AllOpenComponentRegistrar into our resources

so inside src/resources
create a file “org.jetbrains.kotlin.compiler.plugin.CompilerPluginRegistrar”

inside the file just declare the Registerar Qualified Name

makeopen.AllOpenComponentRegistrar

that’s all we created our Compiler Plugin , we now need to make use of it in our app , for that we will need to attach the Jar file to compiler args we will register a simple gradle Task that will do it for us in a separate module “build-logic”

let’s create An Extension for it

abstract class KopenExtension @Inject constructor(
 objects: ObjectFactory
) {
 val kopenEnabled: Property<Boolean> = objects.property(Boolean::class.java).convention(false)
}

then our Convention Plugin

class KopenConventionPlugin : Plugin<Project> {
    override fun apply(target: Project) = with(target) {
        val extension = extensions.create(
            "kopen",
            KopenExtension::class.java,
            objects
        )

        val enableKopenProperty = providers
            .gradleProperty("enableKopen")
            .map { it.toBoolean() }
            .orElse(false)

        extension.kopenEnabled.convention(enableKopenProperty)
        evaluationDependsOn(":make-open")
        val makeOpenJarTask = project(":make-open").tasks.named<Jar>("jar")
        val makeOpenJarFile = makeOpenJarTask.flatMap { it.archiveFile }
        tasks.withType<KotlinCompile>().configureEach {
            dependsOn(makeOpenJarTask)
            compilerOptions.freeCompilerArgs.addAll(
                extension.kopenEnabled.zip(makeOpenJarFile) { enabled, jarFile ->
                    if (enabled) {
                        listOf("-Xplugin=${jarFile.asFile.absolutePath}")
                    } else {
                        emptyList()
                    }
                }
            )
        }
    }
}

for simplicity we will pass the flag to toggle the plugin to work not from a gradle property and it’s false by default so for example during tests we can enable and run it like that

./gradlew test -PenableKopen=true

in the .kts file of your :convention just register the plugin

gradlePlugin {
    plugins {
        register("kopenPlugin") {
            id = "com.mohaberabi.kopen"
            implementationClass = "KopenConventionPlugin"
        }
    }
}

plugins {
    alias(libs.plugins.kotlinMultiplatform)
    alias(libs.plugins.androidApplication)
    alias(libs.plugins.composeMultiplatform)
    alias(libs.plugins.composeCompiler)
    alias(libs.plugins.kopen.plugin)

that’s all we are ready now to mock our classes during tests

final class OrderDao {

    private val orders = MutableStateFlow<List<OrderEntity>>(emptyList())

    fun observeAll(): Flow<List<OrderEntity>> = orders

    suspend fun replaceAll(newOrders: List<OrderEntity>) {
        orders.value = newOrders
    }

    suspend fun clear() {
        orders.value = emptyList()
    }
}

final class OrderLocalDataSource(
    private val dao: OrderDao
) {

    fun observeOrders(): Flow<List<OrderEntity>> = dao.observeAll()

    suspend fun overwriteOrders(orders: List<OrderEntity>) {
        dao.replaceAll(orders)
    }

    suspend fun clear() {
        dao.clear()
    }
}

final class OrderRemoteDataSource(
    private val client: NetworkClient
) {

    suspend fun fetchOrders(): List<OrderDto> {
        return client.getOrders()
    }
}

final class NetworkClient(
    private val baseUrl: String
) {

    suspend fun getOrders(): List<OrderDto> {
        delay(5.seconds)
        return emptyList()
    }
}

final class OrderRepository(
    private val remote: OrderRemoteDataSource,
    private val local: OrderLocalDataSource,
    private val mapper: OrderMapper,
    private val ioDispatcher: CoroutineDispatcher
) {

    fun observeOrders(): Flow<List<Order>> {
        return local
            .observeOrders()
            .map { entities ->
                entities.map { mapper.entityToDomain(it) }
            }
    }

    suspend fun sync(): Result<Unit> {
        return withContext(ioDispatcher) {
            runCatching {
                val remoteOrders = remote.fetchOrders()
                val now = 1000000L
                val entities = remoteOrders.map { mapper.dtoToEntity(it, now) }
                local.clear()
                local.overwriteOrders(entities)
            }
        }
    }
}

final class SyncLogger {

    private val _events = MutableSharedFlow<String>(replay = 0)
    val events: SharedFlow<String> = _events.asSharedFlow()

    suspend fun logSyncStarted() {
        _events.emit("sync_started")
    }

    suspend fun logSyncSuccess(count: Int) {
        _events.emit("sync_success_$count")
    }

    suspend fun logSyncFailure(message: String) {
        _events.emit("sync_failure_$message")
    }
}

sealed class OrdersUiState {
    data object Idle : OrdersUiState()
    data object Loading : OrdersUiState()
    data class Loaded(val orders: List<Order>) : OrdersUiState()
    data class Error(val message: String) : OrdersUiState()
}

final class OrdersViewModel(
    private val repository: OrderRepository,
    private val syncUseCase: SyncOrdersUseCase,
    private val dispatcher: CoroutineDispatcher,
    private val externalScope: CoroutineScope
) {

    private val _state = MutableStateFlow<OrdersUiState>(OrdersUiState.Idle)
    val state: StateFlow<OrdersUiState> = _state.asStateFlow()

    private val _isSyncing = MutableStateFlow(false)
    val isSyncing: StateFlow<Boolean> = _isSyncing.asStateFlow()

    init {
        observeOrders()
    }

    private fun observeOrders() {
        externalScope.launch(dispatcher) {
            repository.observeOrders().collect { orders ->
                if (orders.isNotEmpty()) {
                    _state.value = OrdersUiState.Loaded(orders)
                } else if (_state.value is OrdersUiState.Idle) {
                    _state.value = OrdersUiState.Loading
                }
            }
        }
    }

    fun refresh() {
        if (_isSyncing.value) return
        _isSyncing.value = true

        externalScope.launch(dispatcher) {
            val result = syncUseCase.invoke()
            _isSyncing.value = false

            result.exceptionOrNull()?.let {
                _state.value = OrdersUiState.Error(it.message ?: "unknown")
            }
        }
    }
}

class SyncOrdersUseCaseTest {

    private val repository = mock<OrderRepository>()
    private val logger = mock<SyncLogger>()

    private val useCase = SyncOrdersUseCase(
        repository = repository,
        logger = logger
    )

    @Test
    fun `execute logs start and success on successful sync`() = runTest {
        everySuspend { repository.sync() } returns Result.success(Unit)
        everySuspend { logger.logSyncStarted() } returns Unit
        everySuspend { logger.logSyncSuccess(any()) } returns Unit
        val result = useCase.invoke()
        assertTrue(result.isSuccess)
        verifySuspend { logger.logSyncStarted() }
        verifySuspend { repository.sync() }
        verifySuspend { logger.logSyncSuccess(any()) }
    }

    @Test
    fun `execute logs failure when repository sync fails`() = runTest {
        val error = RuntimeException("network")
        everySuspend { repository.sync() } returns Result.failure(error)
        everySuspend { logger.logSyncStarted() } returns Unit
        everySuspend { logger.logSyncFailure(any()) } returns Unit
        val result = useCase.invoke()
        assertTrue(result.isFailure)
        verifySuspend { logger.logSyncStarted() }
        verifySuspend { repository.sync() }
        verifySuspend { logger.logSyncFailure("network") }
    }
}

@OptIn(ExperimentalCoroutinesApi::class)
class OrdersViewModelTest {

    @Test
    fun `viewModel emits Loaded when repository returns orders`() = runTest {
        val dispatcher = UnconfinedTestDispatcher(testScheduler)
        val repository = mock<OrderRepository>()
        val syncUseCase = mock<SyncOrdersUseCase>()
        val orders = listOf(
            Order(id = "1", total = 10.0, isSynced = true),
            Order(id = "2", total = 20.0, isSynced = false)
        )
        val flow = MutableStateFlow(orders)
        every { repository.observeOrders() } returns flow
        everySuspend { syncUseCase.invoke() } returns Result.success(Unit)

        val vm = OrdersViewModel(
            repository = repository,
            syncUseCase = syncUseCase,
            dispatcher = dispatcher,
            externalScope = backgroundScope,
        )
        val state = vm.state.value
        assertTrue(state is OrdersUiState.Loaded)
        assertEquals(2, state.orders.size)
        verify { repository.observeOrders() }
    }

    @Test
    fun `refresh triggers sync and sets Error on failure`() = runTest {
        val dispatcher = UnconfinedTestDispatcher(testScheduler)
        val repository = mock<OrderRepository>()
        val syncUseCase = mock<SyncOrdersUseCase>()
        val emptyFlow = MutableStateFlow(emptyList<Order>())
        every { repository.observeOrders() } returns emptyFlow
        everySuspend { syncUseCase.invoke() } returns Result.failure(Exception("boom"))
        val vm = OrdersViewModel(
            repository = repository,
            syncUseCase = syncUseCase,
            dispatcher = dispatcher,
            externalScope = backgroundScope,
        )

        vm.refresh()
        verifySuspend { syncUseCase.invoke() }
        val state = vm.state.value
        assertTrue(state is OrdersUiState.Error)
        assertEquals("boom", state.message)
    }
}

@OptIn(ExperimentalCoroutinesApi::class)
class OrderRepositoryTest {

    private val dispatcher = StandardTestDispatcher()
    private val testScope = TestScope(dispatcher)

    private val remote = mock<OrderRemoteDataSource>()
    private val local = mock<OrderLocalDataSource>()
    private val mapper = OrderMapper()

    @Test
    fun `sync should fetch remote orders and write to local`() = testScope.runTest {
        val dtoList = listOf(
            OrderDto(id = "1", total = 100.0, status = "NEW"),
            OrderDto(id = "2", total = 200.0, status = "PAID")
        )
        everySuspend { remote.fetchOrders() } returns dtoList
        everySuspend { local.clear() } returns Unit
        everySuspend { local.overwriteOrders(any()) } returns Unit
        val repo = OrderRepository(
            remote = remote,
            local = local,
            mapper = mapper,
            ioDispatcher = dispatcher
        )
        val result = repo.sync()
        assertTrue(result.isSuccess)
        verifySuspend() { remote.fetchOrders() }
        verifySuspend() { local.clear() }
        verifySuspend() { local.overwriteOrders(any()) }
    }

    @Test
    fun `observeOrders should map entities to domain`() = testScope.runTest {
        val dao = OrderDao()
        val localReal = OrderLocalDataSource(dao)
        val repo = OrderRepository(
            remote = remote,
            local = localReal,
            mapper = mapper,
            ioDispatcher = dispatcher
        )

        val entities = listOf(
            OrderEntity("1", 10.0, "NEW", syncedAtMillis = null),
            OrderEntity("2", 20.0, "NEW", syncedAtMillis = 1234L)
        )
        dao.replaceAll(entities)
        val result = repo.observeOrders().first()
        assertEquals(2, result.size)
        assertEquals(false, result[0].isSynced)
        assertEquals(true, result[1].isSynced)
    }
}

now run

./gradlew test -PenableKopen=true

source code : https://github.com/mohaberabi/kopen

Logging http calls is one of the most needed essential setup during your application development , i really always use Chucker ( Android ) but i wanted to see how it might be if i wanted the same experience on IOS , but since my background is not that enough to do it in IOS i tried to build it in Kotlin MultiPlatform , and here is the thing it was really a great and amazing expereince

So I built Inspekt — a fully Kotlin Multiplatform network inspector:

• Works with Ktor HTTP client
• Logs requests + responses
• Pretty-prints JSON
• Handles binary bodies
• Saves logs using Room on Android + Room KMP on iOS
• Sends local notifications on both platforms
• Adds app shortcuts
• Opens a UI overlay on iOS using pure Kotlin/Native
• Shows a full UI built with Compose Multiplatform
• 0 lines of Swift
• 0 lines of Objective-C

A full Compose Multiplatform screen showing:

• Requests
• Responses
• Headers
• Status codes
• Body pretty-printing
• Metrics
• Colors
• Durations
• Size

Notifications

Every request triggers a local notification with:

• URL
• Status
• Tap → open Inspekt screen

Home-screen shortcuts

Tap “Open Inspekt” → jump directly to the inspector.

Full Ktor plugin

Works exactly like Chucker but cross-platform.

Below is our data that will be saved inside Room Database

@Serializable
enum class InspektStatus {
 RequestSent,
 Completed,
 Unknown,
 Failure,
}
@Serializable
data class HttpLogEntry(
 @SerialName("id") val id: String,
 @SerialName("timestamp_millis") val timestampMillis: Long,
 @SerialName("response_millis") val responseTimeStampMillis: Long? = null,
 @SerialName("method") val method: String,
 @SerialName("url") val url: String,
 @SerialName("status_code") val statusCode: Int? = null,
 @SerialName("request_headers") val requestHeaders: Map<String, String>,
 @SerialName("response_headers") val responseHeaders: Map<String, String>,
 @SerialName("request_body") val requestBody: String? = null,
 @SerialName("response_body") val responseBody: String? = null,
 @SerialName("duration_millis") val durationMillis: Long?,
 @SerialName("error") val error: String? = null,
 @SerialName("request_size_bytes") val requestSizeBytes: Long = 0L,
 @SerialName("response_size_bytes") val responseSizeBytes: Long? = null,
 @SerialName("protocol") val protocol: String? = null,
 @SerialName("ssl") val ssl: Boolean? = null,
 @SerialName("inspekt_status") val inspektStatus: InspektStatus = InspektStatus.Unknown,
 @SerialName("host") val host: String? = null,
 @SerialName("path") val endPoint: String? = null,
 @SerialName("content_type") val contentType: String? = null,
 @SerialName("accept_charset") val acceptCharset: String? = null,
 @SerialName("content_length") val contentLength: Long? = null,
)

fun MainViewController() = ComposeUIViewController(
    configure = {
        val strategy = InspektConfigStrategy.Actual(
            config = InspektConfig(),
            notificationEnabled = true,
            shortcutEnabled = true,
            maxPersistenceEntry = 50
        )
        GlobalInspekt.configure(
            strategy = strategy
        )
        requestNotificationPermission()
        setupDelegates()
    }
) { App() }

class InspektApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        GlobalInspekt.configure(
            strategy = InspektConfigStrategy.Actual(
                config = InspektConfig(this),
                notificationEnabled = true,
                shortcutEnabled = true,
                maxPersistenceEntry = 10
            )
        )
    }
}

Building the Ktor Plugin: Capturing Requests, Responses & Bodies Without Breaking the Pipeline

fun InspektPlugin() = createClientPlugin(
    name = NAME,
    createConfiguration = { ... }
) {
    onRequest { request, body -> ... }

    client.receivePipeline.intercept(HttpReceivePipeline.After) { response -> ... }
}

Request Pipeline

Called before the HTTP call is executed.

Best place to extract:

• URL
• Path
• Query
• Headers
• Method
• Request body

Receive Pipeline

Called after receiving the raw response bytes, BEFORE the user gets them.

This is where we capture:

• Response headers
• Body
• Status code
• Duration

And MOST importantly:

We clone the response body so the user can still call body<T>() without error.

Logging Requests

internal fun ClientPluginBuilder<InspektConfig>.onInspektRequest() {
    val inspekt = pluginConfig.inspekt
    val scope = pluginConfig.scope
    val requestDecoder = pluginConfig.requestBodyDecoder

    onRequest { request, _ ->
        val time = getTimeMillis()
        val callId = generateCallId(time = time, value = request.hashCode())

        val entry = request.toLogEntry(callId = callId, millis = time)

        val rawBytes = request.body.extractRawContent()

        val decodedBody: String = requestDecoder
            .decode(entry, rawBytes)
            ?: rawBytes.decodeReadable(request.headers.extractContentType())

        val newEntry = entry.copy(requestBody = decodedBody)

        request.attributes.put(CallIdKey, callId)
        request.attributes.put(CallStartMillisKey, time)
        request.attributes.put(EntryKey, entry)

        scope.launch {
            inspekt.logCall(newEntry)
        }
    }
}

internal fun Any?.extractRawContent() = when (this) {
    null -> byteArrayOf()
    is String -> encodeToByteArray()
    is ByteArray -> this
    is OutgoingContent.ByteArrayContent -> this.bytes()
    is OutgoingContent.ReadChannelContent -> "<streaming body>".encodeToByteArray()
    else -> this.toString().encodeToByteArray()
}

val decodedBody = requestDecoder.decode(entry, rawBytes)
    ?: rawBytes.decodeReadable(request.headers.extractContentType())

Logging Responses — The Hard Part

Capture the body

Clone it

Preserve original behavior

Pretty-print if JSON

Decode custom formats

internal fun HttpClient.inspektReceive(
    inspekt: Inspekt,
    scope: CoroutineScope,
    responseDecoder: InspektBodyDecoder,
) {
    receivePipeline.intercept(HttpReceivePipeline.After) { response ->

        val start = response.request.attributes.getOrNull(CallStartMillisKey) ?: getTimeMillis()

        val call = response.call
        val channel = response.bodyAsChannel()

        val bytes = channel.readRemaining().readByteArray()

        val newCall = call.replaceResponse {
            ByteReadChannel(bytes)
        }

        val now = getTimeMillis()
        val duration = now - start

        val entry = call.attributes.getOrNull(EntryKey) ?: return@intercept

        val completedEntry = entry.copy(
            durationMillis = duration,
            responseHeaders = response.headers.entries()
                .associate { it.key to it.value.joinToString() },
            statusCode = response.status.value,
            responseSizeBytes = bytes.size.toLong(),
            inspektStatus = InspektStatus.Completed
        )

        val rawBytes = bytes.extractRawContent()

        val decodedBody: String = responseDecoder
            .decode(entry, rawBytes)
            ?: rawBytes.decodeReadable(entry.contentType)

        val newEntry = completedEntry.copy(responseBody = decodedBody)

        scope.launch { inspekt.logCall(newEntry) }

        proceedWith(newCall.response)
    }
}

bodyAsChannel()

This gives you access to the raw bytes of the server response.

But reading it consumes it.

So after reading:

val bytes = channel.readRemaining().readByteArray()

You cannot return this channel to the user.

Rebuilding the response

val newCall = call.replaceResponse {
    ByteReadChannel(bytes)
}

We:

1. Read bytes once
2. Rebuild a new response body
3. Send the new cloned body back to Ktor

This ensures:

User can still call .body<T>()

Inspekt gets a full copy

No crashes

No double read

Notifications, Shortcuts & a Floating Overlay Window…

On Android:

• We can launch new activities
• We can inject activities via manifest
• We can overlay windows
• We can create shortcuts dynamically
• We can intercept notification taps easily
• We can use PendingIntent

On iOS:

• No Activities
• No deep dynamic window creation
• Only ONE UIApplicationDelegate allowed
• Notifications need a UNUserNotificationCenterDelegate
• Shortcuts need a UIApplicationDelegate callback
• UIKit windows cannot be manually inserted incorrectly
• App extensions cannot be shipped inside libraries

so on ios we will need to hock into the delegates without overriding them so i decided to give user a callback to invoke them inside their delegates

class IosShortcutDelegate(
    private val onItemOpenedApp: (item: UIApplicationShortcutItem) -> Unit = {},
) : UIResponder(), UIApplicationDelegateProtocol {

    override fun application(
        application: UIApplication,
        performActionForShortcutItem: UIApplicationShortcutItem,
        completionHandler: (Boolean) -> Unit
    ) {
        onItemOpenedApp(performActionForShortcutItem)
    }
}

class InspektNotificationDelegate(
    private val onReceivedNotification: (UNNotification) -> Unit = {},
    private val onNotificationClicked: (UNNotification) -> Unit = {}
) : NSObject(), UNUserNotificationCenterDelegateProtocol {

    override fun userNotificationCenter(
        center: UNUserNotificationCenter,
        didReceiveNotificationResponse: UNNotificationResponse,
        withCompletionHandler: () -> Unit
    ) {
        onNotificationClicked(didReceiveNotificationResponse.notification)
        withCompletionHandler()
    }
}

class IosNotificationManager : InspektNotificationManager {

    override fun showLocalNotification(
        title: String,
        body: String,
        id: Int,
        config: NotificationConfig
    ) = dispatch_async(queue = dispatch_get_main_queue()) {
        val content = UNMutableNotificationContent()
            .apply {
                setTitle(title)
                setBody(body)
                setSound(UNNotificationSound.defaultSound())
                setUserInfo(config.userInfo)
            }

        val triggerTime = UNTimeIntervalNotificationTrigger.triggerWithTimeInterval(
            timeInterval = 5.0,
            repeats = false
        )

        val request = UNNotificationRequest.requestWithIdentifier(
            identifier = "$id",
            content = content,
            trigger = triggerTime,

            )
        UNUserNotificationCenter.currentNotificationCenter()
            .addNotificationRequest(request = request)
            { error ->
                println("IosNotificationManager---${error}")
            }
    }
}

actual class NotificationConfig(
    val userInfo: Map<Any?, Any?> = mapOf()
)

on Android it’s really simple you just add your pending intent inside the notification and that’s it no delegates

class AndroidInspektNotificationManager(
    private val context: Context
) : InspektNotificationManager {
    companion object {
        const val CHANNEL_ID = "Inspekt"
    }


    private val notificationManager by lazy { requireNotNull(context.getSystemService<NotificationManager>()); }
    override fun showLocalNotification(
        title: String,
        body: String,
        id: Int,
        config: NotificationConfig
    ) {

        val builder = NotificationCompat.Builder(
            context,
            CHANNEL_ID
        )
        val notification = builder
            .setContentTitle(title)
            .setContentText(body)
            .setChannelId(CHANNEL_ID)
            .setSmallIcon(R.drawable.ic_launcher_foreground)
            .setContentIntent(config.contentPendingIntent)
            .build()
        notificationManager.notify(id, notification)
    }

    fun initChannel() {
        if (Build.VERSION.SDK_INT >= 33) {
            runCatching {
                val channel = NotificationChannel(
                    CHANNEL_ID,
                    CHANNEL_ID,
                    NotificationManager.IMPORTANCE_DEFAULT
                )
                notificationManager.createNotificationChannel(channel)
            }
        }

    }
}

actual class NotificationConfig(
    val contentPendingIntent: PendingIntent
)

Now Shortcuts to open the logging screen

interface AppShortcutManager {
    fun addShortcut(shortcut: AppShortcut)
    fun removeShortcutById(id: String)
}

expect class AppShortcutConfig

data class AppShortcut(
    val id: String,
    val longName: String,
    val shortName: String,
    val config: AppShortcutConfig
)

on Android and IOS They are almost exactly the same , only the difference that you receive the intention of clicking the shortcut via Delegate in IOS

Android

class AndroidShortcutManager(
    private val context: Context,
) : AppShortcutManager {
    override fun addShortcut(shortcut: AppShortcut) {
        val icon = shortcut.config.icon
        val intent = shortcut.config.intent
        val shortcut = ShortcutInfoCompat.Builder(context, shortcut.id)
            .setShortLabel(shortcut.shortName)
            .setLongLabel(shortcut.longName)
            .setIcon(icon)
            .setIntent(intent)
            .build()
        ShortcutManagerCompat.pushDynamicShortcut(context, shortcut)
    }

    override fun removeShortcutById(id: String) {
        ShortcutManagerCompat.removeDynamicShortcuts(context, listOf(id))
    }

actual class AppShortcutConfig(
    val intent: Intent,
    val icon: IconCompat
)

IOS

class IosShortcutManager() : AppShortcutManager {
    override fun addShortcut(shortcut: AppShortcut) {
        val app = UIApplication.sharedApplication
        val shortcuts = app.shortcutItems.orEmpty()
        val exists = shortcuts.any {
            val item = it as? UIApplicationShortcutItem ?: return@any false
            if (item.type == shortcut.id) return@any true
            false
        }
        if (exists) return
        val newShortcuts = mutableListOf<Any?>()
        newShortcuts.addAll(shortcuts)
        val shortcut = UIApplicationShortcutItem(
            type = shortcut.id,
            localizedTitle = shortcut.shortName,
            localizedSubtitle = shortcut.longName,
            userInfo = shortcut.config.userInfo,
            icon = shortcut.config.icon,
        )
        newShortcuts.add(shortcut)
        app.shortcutItems = newShortcuts
    }

    override fun removeShortcutById(id: String) {
        val app = UIApplication.sharedApplication
        if (app.shortcutItems.isNullOrEmpty()) return
        val shortcuts = app.shortcutItems.orEmpty().filter {
            if (it is UIApplicationShortcutItem) {
                it.type != id
            } else {
                true
            }
        }
        app.shortcutItems = shortcuts
    }
}

actual class AppShortcutConfig(
    val userInfo: Map<Any?, Any?>,
    val icon: UIApplicationShortcutIcon,
)

as we already know it’s very easy now to use the Room Jetpack from Android inside IOS As Well , so we will have a simple DAO as for now

@Dao
interface HttpLogDao {

    @Upsert
    suspend fun upsert(entity: HttpLogEntity)

    @Query("SELECT COUNT(*) FROM http_log")
    suspend fun count(): Long


    @Query("DELETE FROM http_log")
    suspend fun clear()

    @Query("SELECT * FROM http_log ORDER BY timeStamp DESC")
    fun getAll(): Flow<List<HttpLogEntity>>
}

and that’s it we created now our interfaces that our tool will be using

let’s create our actual library Facade in :commonMain

expect class InspektConfig {}

sealed interface InspektConfigStrategy {
    data object NoOperation : InspektConfigStrategy
    data class Actual(
        val config: InspektConfig,
        val notificationEnabled: Boolean = true,
        val shortcutEnabled: Boolean = true,
        val maxPersistenceEntry: Long = 100L
    ) : InspektConfigStrategy
}

internal const val INSPEKT = "inspekt"
internal const val SHORTCUT_TITLE = "Open Inspekt"
internal const val SHORTCUT_SUBTITLE = "to inspect and log your http calls"

internal const val DB_NAME = "${INSPEKT}.db"
internal fun inspektNotInitializedError(): Nothing =
    error("GlobalInspekt instance is not initialized u forgot to call configure or configureNonImpl")

@Suppress("EXPECT_ACTUAL_CLASSIFIERS_ARE_IN_BETA_WARNING")
expect class GlobalInspekt {
    companion object {
        val sharedInstance: Inspekt
        fun configure(strategy: InspektConfigStrategy)

    }

}

interface Inspekt {

    suspend fun logCall(entry: HttpLogEntry)

    fun observeEntries(): Flow<List<HttpLogEntry>>
}

internal class InspektImpl(
    private val strategy: InspektConfigStrategy.Actual,
    private val notificationManager: InspektNotificationManager,
    private val dao: HttpLogDao,
    private val notificationConfigProvider: NotificationConfigProvider
) : Inspekt {
    private val mutex = Mutex()
    override suspend fun logCall(
        entry: HttpLogEntry,
    ) = supervisorScope {
        mutex.withLock {
            val jobs = buildList {
                addIf(strategy.notificationEnabled) { sendNotification(entry) }
                add(upsert(entry))
            }
            jobs.joinAll()
        }
    }

    private fun CoroutineScope.upsert(
        entry: HttpLogEntry,
    ) = launch {
        val count = dao.count()
        if (count >= strategy.maxPersistenceEntry) {
            dao.clear()
        }
        dao.upsert(HttpLogEntity(entry))
    }

    private fun CoroutineScope.sendNotification(
        entry: HttpLogEntry,
    ) = launch {
        val status = entry.statusCode?.let { "$it" } ?: ""
        notificationManager.showLocalNotification(
            title = entry.url,
            body = "Logging the call $status",
            id = entry.id.hashCode(),
            config = notificationConfigProvider.provideInspektNotificationConfig()
        )
    }

    override fun observeEntries(): Flow<List<HttpLogEntry>> {
        return dao.getAll().map { list -> list.map { it.log } }
    }

    private inline fun <reified T> MutableList<T>.addIf(
        predicate: Boolean,
        block: () -> T
    ) {
        if (predicate) {
            add(block())
        }
    }
}

internal expect class NotificationConfigProvider {

    fun provideInspektNotificationConfig(): NotificationConfig
}

internal expect class ShortcutConfigProvider {

    fun provideInspektShortcutConfig(): AppShortcutConfig
}

Android Side :

actual class GlobalInspekt {
    actual companion object {
        private var androidInstance: Inspekt? = null

        actual val sharedInstance: Inspekt
            get() = androidInstance ?: inspektNotInitializedError()

        actual fun configure(
            strategy: InspektConfigStrategy
        ) {
            when (strategy) {
                is InspektConfigStrategy.Actual -> configureActualImpl(strategy)
                InspektConfigStrategy.NoOperation -> configureNoOperation()
            }
        }

        private fun configureActualImpl(
            strategy: InspektConfigStrategy.Actual,
        ) {
            if (androidInstance != null) return
            val config = strategy.config
            val context = config.context
            val notificationManager = AndroidInspektNotificationManager(context = context)
                .apply { initChannel() }
            val builder = RoomDatabaseBuilder(context)
            val database = builder.create<InspektDatabase>(DB_NAME).build()
            val dao = database.httpLodDao()
            val notificationConfigProvider =
                NotificationConfigProvider(context)
            val inspekt = InspektImpl(
                notificationManager = notificationManager,
                dao = dao,
                notificationConfigProvider = notificationConfigProvider,
                strategy = strategy
            )
            configureShortcut(
                context = context,
                shortcutEnabled = strategy.shortcutEnabled
            )
            androidInstance = inspekt
        }

        private fun configureShortcut(
            context: Context,
            shortcutEnabled: Boolean,
        ) {
            runCatching {
                val manager = AndroidShortcutManager(context)
                if (shortcutEnabled) {
                    val configProvider = ShortcutConfigProvider(context)
                    val config = configProvider.provideInspektShortcutConfig()
                    val shortcut = AppShortcut(
                        id = INSPEKT,
                        longName = SHORTCUT_TITLE,
                        shortName = SHORTCUT_SUBTITLE,
                        config = config
                    )
                    manager.addShortcut(shortcut)
                } else {
                    manager.removeShortcutById(INSPEKT)
                }

            }

        }

        private fun configureNoOperation() {
            androidInstance = EmptyInspekt
        }
    }


}

internal actual class NotificationConfigProvider(
    private val context: Context
) {
    actual fun provideInspektNotificationConfig(): NotificationConfig {
        val intent = Intent(context, InspektActivity::class.java)
            .applyInspekt(context.getAppName())
        val pendingIntent = PendingIntent.getActivity(
            context,
            201098,
            intent,
            PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
        )
        return NotificationConfig(contentPendingIntent = pendingIntent)
    }
}

internal actual class ShortcutConfigProvider(
    private val context: Context
) {
    actual fun provideInspektShortcutConfig(): AppShortcutConfig {
        val intent = Intent(context, InspektActivity::class.java)
            .applyInspekt(context.getAppName())
        return AppShortcutConfig(
            intent = intent,
            icon = IconCompat.createWithResource(
                context,
                R.drawable.ic_launcher_foreground
            )
        )
    }
}

some utils used inside android side

internal fun Context.getAppName(): String {
    val labelRes = applicationInfo.labelRes
    return if (labelRes != 0) {
        getString(labelRes)
    } else {
        applicationInfo.nonLocalizedLabel.toString()
    }
}


internal fun Intent.applyInspekt(appName: String) = apply {
    action = Intent.ACTION_VIEW
    flags += Intent.FLAG_ACTIVITY_NEW_TASK
    putExtra("root_launcher", appName)
}

IOS Side :

actual class GlobalInspekt {
    actual companion object {

        private var iosInstance: Inspekt? = null

        private val inspektViewController by lazy {
            InspektViewController(
                onDismiss = InspektViewControllerPresenter::dismiss,
            )
        }

        actual val sharedInstance: Inspekt
            get() = iosInstance ?: inspektNotInitializedError()

        actual fun configure(
            strategy: InspektConfigStrategy
        ) {
            when (strategy) {
                is InspektConfigStrategy.Actual -> configureActual(strategy)
                InspektConfigStrategy.NoOperation -> configureNoOperation()
            }
        }

        private fun configureActual(
            strategy: InspektConfigStrategy.Actual,
        ) {
            if (iosInstance != null) return
            val dao = setupDatabase()
            val inspekt = InspektImpl(
                notificationManager = IosNotificationManager(),
                dao = dao,
                notificationConfigProvider = NotificationConfigProvider(),
                strategy = strategy
            )
            setupShortcut(shortcutEnabled = strategy.shortcutEnabled)
            iosInstance = inspekt
        }

        private fun configureNoOperation() {
            iosInstance = EmptyInspekt
        }

        private fun setupDatabase(): HttpLogDao {
            val builder = RoomDatabaseBuilder()
            val database = builder.create<InspektDatabase>(DB_NAME).build()
            val dao = database.httpLodDao()
            return dao
        }

        private fun setupShortcut(
            shortcutEnabled: Boolean,
        ) {
            runCatching {
                val shortcutManager = IosShortcutManager()
                if (shortcutEnabled) {
                    val shortCutConfigProvider = ShortcutConfigProvider()
                    val shortCut = AppShortcut(
                        id = INSPEKT,
                        longName = SHORTCUT_SUBTITLE,
                        shortName = SHORTCUT_TITLE,
                        config = shortCutConfigProvider.provideInspektShortcutConfig()
                    )
                    shortcutManager.addShortcut(shortCut)
                } else {
                    shortcutManager.removeShortcutById(INSPEKT)
                }
            }

        }

        fun shortcutOpenedApp(item: UIApplicationShortcutItem) {
            if (item.type == INSPEKT) {
                openInspektView()
            }
        }


        fun notificationClicked(notification: UNNotification) {
            val data = notification.request.content.userInfo
            if (data[INSPEKT] != null) {
                openInspektView()
            }
        }

        private fun openInspektView() {
            InspektViewControllerPresenter.show(inspektViewController)
        }
    }


}

internal actual class NotificationConfigProvider {
    actual fun provideInspektNotificationConfig(): NotificationConfig {
        return NotificationConfig(
            userInfo = mapOf("inspekt" to true)
        )
    }
}

internal actual class ShortcutConfigProvider {
    actual fun provideInspektShortcutConfig(): AppShortcutConfig {
        return AppShortcutConfig(
            userInfo = mapOf(),
            icon = UIApplicationShortcutIcon.iconWithSystemImageName("paperplane.fill")
        )
    }
}

that’s all we just now need to create some client app and install our plugin inside it’s Ktor Client then inspekt the calls

@Serializable
data class PostDto(
    val id: Int,
    val title: String,
    val content: String
)

@Composable
fun App() {
    MaterialTheme { HomeScreen(); }
}


@Composable
fun HomeScreen() {
    val scope = rememberCoroutineScope()
    Scaffold { padding ->
        Column(
            modifier = Modifier.fillMaxSize()
                .padding(padding)
                .padding(20.dp),
            horizontalAlignment = Alignment.CenterHorizontally,
            verticalArrangement = Arrangement.Center
        ) {
            Text("My Client App")
            Button(
                onClick = {
                    scope.launch {
                        val jobs = (1..10).map {
                            scope.launch {
                                val client = httpClient()
                                val post: PostDto =
                                    client.get("https://jsonplaceholder.org/posts/1").body()
                            }
                        }.joinAll()
                    }

                },
            ) {
                Text("Make 10 http call")
            }

        }
    }
}

fun httpClient(
) = HttpClient(createEngine()) {

    install(Logging) {
        logger = object : Logger {
            override fun log(message: String) {
                println(message)
            }
        }
    }
    install(ContentNegotiation) {
        json(
            json = Json {
                encodeDefaults = true
                explicitNulls = false
                ignoreUnknownKeys = true
            },
        )
    }
    install(InspektPlugin())

    defaultRequest {
        accept(ContentType.Application.Json)
    }
}


expect fun createEngine(): HttpClientEngine

Now Let’s Initialize Our Library

fun MainViewController() = ComposeUIViewController(
    configure = {
        val strategy = InspektConfigStrategy.Actual(
            config = InspektConfig(),
            notificationEnabled = true,
            shortcutEnabled = true,
            maxPersistenceEntry = 50
        )
        GlobalInspekt.configure(
            strategy = strategy
        )
        requestNotificationPermission()
        setupDelegates()
    }
) { App() }

private val rootAppDelegate = RootAppDelegate(
    onItemOpenedApp = GlobalInspekt::shortcutOpenedApp
)

private val notificationDelegate = UNNotificationDelegate(
    onNotificationClicked = GlobalInspekt::notificationClicked
)


private fun setupDelegates() {
    UNUserNotificationCenter.currentNotificationCenter().delegate = notificationDelegate
    UIApplication.sharedApplication.setDelegate(rootAppDelegate)
}

fun requestNotificationPermission() {
    val center = UNUserNotificationCenter.currentNotificationCenter()
    center.requestAuthorizationWithOptions(
        options = UNAuthorizationOptionAlert or
                UNAuthorizationOptionSound or
                UNAuthorizationOptionBadge
    ) { granted, _ -> ; }
}

class InspektApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        GlobalInspekt.configure(
            strategy = InspektConfigStrategy.Actual(
                config = InspektConfig(this),
                notificationEnabled = true,
                shortcutEnabled = true,
                maxPersistenceEntry = 10
            )
        )
    }
}

Source Code : https://github.com/mohaberabi/inspekt

One Source of Truth: Managing Android & iOS Versions — Flavors with a Kotlin Multiplatform Gradle Plugin

Ever found yourself hardcoding version codes, build types, or bundle identifiers across your Kotlin Multiplatform project? Wished you could access Android’s BuildConfig values in your iOS code, or vice versa? Meet Kommon Versions — a Gradle convention plugin that generates platform-specific build configuration that's accessible from shared code.

In a typical KMP project, managing build configurations is fragmented. Android has BuildConfig, iOS relies on Info.plist and xcconfig files, and your shared code is left in the dark. You end up with:

• Duplicated version strings across platform-specific files
• No type-safe way to access build metadata in common code
• Manual synchronization nightmares when updating versions or flavors

Kommon Versions is a custom Gradle plugin that automatically generates a unified KommonVersions object accessible from all your KMP targets. It bridges the gap between Android's build system and iOS configuration, exposing everything through Kotlin's expect/actual pattern.

// Access anywhere in your shared code!
Text("App ID: ${KommonVersions.APPLICATION_ID}")
Text("Version: ${KommonVersions.VERSION_NAME}")
Text("Build Type: ${KommonVersions.BUILD_TYPE}")
Text("Flavor: ${KommonVersions.FLAVOR}")

The plugin uses Gradle’s convention plugins and code generation to create platform-specific implementations:

1. Common Code Generation

The plugin generates an expect object in commonMain:

expect object KommonVersions {
 val APPLICATION_ID: String
 val BUILD_TYPE: String
 val VERSION_CODE: Int
 val VERSION_NAME: String
 val FLAVOR: String
}

2. Android Implementation

For Android, it taps into the existing BuildConfig class:

actual object KommonVersions {
 actual val APPLICATION_ID: String = BuildConfig.APPLICATION_ID
 actual val BUILD_TYPE: String = BuildConfig.BUILD_TYPE
 actual val VERSION_CODE: Int = BuildConfig.VERSION_CODE
 actual val VERSION_NAME: String = BuildConfig.VERSION_NAME
 actual val FLAVOR: String = BuildConfig.FLAVOR
}

3. iOS Implementation

For iOS, it reads values from the app bundle at runtime:

actual object KommonVersions {
 private val bundleMap = NSBundle.mainBundle.infoDictionary
 
 actual val APPLICATION_ID = getString("CFBundleIdentifier")
 actual val BUILD_TYPE = if (Platform.isDebugBinary) "debug" else "release"
 actual val VERSION_CODE = getString("CFBundleVersion").toIntOrNull() ?: 1
 actual val VERSION_NAME = getString("CFBundleShortVersionString")
 actual val FLAVOR = getString("AppScheme")
}

4. XCConfig File Generation

The plugin even generates iOS xcconfig files automatically, keeping your Xcode project in sync:

TEAM_ID=
PRODUCT_BUNDLE_IDENTIFIER=com.mohaberabi.buildversionkmp.dev
PRODUCT_NAME=KmpVersionDevelop
MARKETING_VERSION=0.0.1
CURRENT_PROJECT_VERSION=1
KOTLIN_FRAMEWORK_BUILD_TYPE=Debug
XCODE_CONFIGURATION=Debug-development
APP_SCHEME=development

Configuration DSL

The plugin provides a clean, DSL for configuring both platforms:

commonVersions {
    android = android {
        namespace = "com.example.app"
        versionCode = 1
        versionName = "0.0.1"
        flavorDimensions += "default"
        
        flavors += flavor {
            name = "dev"
            dimension = "default"
            versionNameSuffix = "-dev"
            appName = "MyApp"
            appNameSuffix = "Dev"
            applicationIdSuffix = ".dev"
        }
    }
    
    ios = ios {
        projectFolderName = "iosApp"
        appName = "MyApp"
        bundleId = "com.example.app"
        marketingVersion = "0.0.1"
        currentVersion = "1"
        
        schemas += schema {
            name = "development"
            nameSuffix = "Dev"
            bundleSuffix = "dev"
        }
    }
}

The CommonVersionConventionPlugin applies the KMP plugin and registers code generation tasks:

class CommonVersionConventionPlugin : Plugin<Project> {
    override fun apply(target: Project) {
        with(target) {
            pluginManager.apply("org.jetbrains.kotlin.multiplatform")
            
            val ext = extensions.create(
                "commonVersions",
                CommonVersionsExtension::class.java
            )
            
            afterEvaluate {
                configureAndroid(ext.android.orNull)
                configureIos(ext.ios.orNull)
                registerCodeGenTask()
            }
        }
    }
}

fun Project.configureKmpVersion() {
    extensions.configure<KotlinMultiplatformExtension> {
        val buildDir = layout.buildDirectory.dir("generated/kotlin")
        sourceSets["commonMain"]?.kotlin?.srcDir(buildDir)
        sourceSets["androidMain"]?.kotlin?.srcDir(buildDir)
        sourceSets["iosMain"]?.kotlin?.srcDir(buildDir)
    }
}

tasks.matching { task ->
    task.name.contains("ios", ignoreCase = true) && 
    task.name.contains("Link", ignoreCase = true)
}.configureEach {
    dependsOn(generateIosConfigTask)
}

• Single Source of Truth: Define versions once in gradle/libs.versions.toml
• Platform Consistency: Same configuration values accessible across Android, iOS, and shared code
• Automated XCConfig: No manual Xcode project editing needed
• Flavor Support: Full support for Android product flavors and iOS schemes

source : https://github.com/mohaberabi/kommon-versions

Building secure apps means protecting sensitive data — tokens, secrets, user credentials, encryption keys — at rest.

For Android developers this usually means Keystore, while iOS developers rely on Keychain.

This article walks through the exact pattern you should use:

• A unified secure storage interface in commonMain
• Android implementation using AES-GCM + Android Keystore
• iOS implementation using AES-GCM + Keychain

Step 1 — Common API (commonMain)

expect object Krypto {

    fun encrypt(bytes: ByteArray): ByteArray
    fun decrypt(bytes: ByteArray): ByteArray
}

it’s very common that we will use this also for strings and text so let’s make a utils functions that will help us

@OptIn(ExperimentalEncodingApi::class)
fun Krypto.encrypt(text: String): String {
    if (text.isBlank()) return ""
    val plainBytes = text.encodeToByteArray()
    val cipherBytes = Krypto.encrypt(plainBytes)
    return Base64.encode(cipherBytes)
}

@OptIn(ExperimentalEncodingApi::class)
fun Krypto.decrypt(encryptedText: String): String {
    if (encryptedText.isBlank()) return ""
    val cipherBytes = Base64.decode(encryptedText)
    val plainBytes = Krypto.decrypt(cipherBytes)
    return plainBytes.decodeToString()
}

Step 2 — Android Implementation (androidMain)

actual object Krypto {
    private const val PROVIDER = "AndroidKeyStore"
    private const val ALGORITHM = KeyProperties.KEY_ALGORITHM_AES
    private const val BLOCK_MODE = KeyProperties.BLOCK_MODE_CBC
    private const val PADDING = KeyProperties.ENCRYPTION_PADDING_PKCS7
    private const val TRANSFORMATION = "$ALGORITHM/$BLOCK_MODE/$PADDING"

    private val keyGenerator by lazy { KeyGenerator.getInstance(ALGORITHM, PROVIDER); }
    private val cipher by lazy { Cipher.getInstance(TRANSFORMATION); }
    private val keyStore by lazy { KeyStore.getInstance(PROVIDER).apply { load(null); }; }

    actual fun encrypt(bytes: ByteArray): ByteArray {
        cipher.init(Cipher.ENCRYPT_MODE, getKey())
        val iv = cipher.iv
        val encrypted = cipher.doFinal(bytes)
        return iv + encrypted
    }

    actual fun decrypt(bytes: ByteArray): ByteArray {
        val iv = bytes.copyOfRange(0, cipher.blockSize)
        val data = bytes.copyOfRange(cipher.blockSize, bytes.size)
        cipher.init(Cipher.DECRYPT_MODE, getKey(), IvParameterSpec(iv))
        return cipher.doFinal(data)
    }

    private fun getKey(): SecretKey {
        val existing = keyStore.getEntry(AES_KEY_ALIAS, null) as? KeyStore.SecretKeyEntry
        return existing?.secretKey ?: createKey()
    }

    private fun createKey(): SecretKey {
        val builder = KeyGenParameterSpec.Builder(
            AES_KEY_ALIAS,
            KeyProperties.PURPOSE_ENCRYPT or
                    KeyProperties.PURPOSE_DECRYPT
        ).setBlockModes(BLOCK_MODE)
            .setEncryptionPaddings(PADDING)
            .setRandomizedEncryptionRequired(true)
            .setUserAuthenticationRequired(false)
            .setKeySize(256)
        return keyGenerator.apply { init(builder.build()); }.generateKey()
    }
}

private const val PROVIDER = "AndroidKeyStore"
    private const val ALGORITHM = KeyProperties.KEY_ALGORITHM_AES
    private const val BLOCK_MODE = KeyProperties.BLOCK_MODE_CBC
    private const val PADDING = KeyProperties.ENCRYPTION_PADDING_PKCS7
    private const val TRANSFORMATION = "$ALGORITHM/$BLOCK_MODE/$PADDING"

• PROVIDER = “AndroidKeyStore”
• We tell Java Crypto: “Use the Android keystore system” as the place where the secret key lives.
• ALGORITHM = AES
• We’re using AES (symmetric encryption). Same key for encryption & decryption.
• BLOCK_MODE = CBC
• We use Cipher Block Chaining (CBC) mode.
• Each block depends on previous one, needs an IV (initialization vector).
• PADDING = PKCS7
• If the data isn’t a multiple of AES block size (16 bytes), we add padding bytes so it fits.
• TRANSFORMATION = “AES/CBC/PKCS7Padding”
• Algorithm / BlockMode / Padding
• That’s exactly what you pass into Cipher.getInstance(…).

private val keyGenerator by lazy { KeyGenerator.getInstance(ALGORITHM, PROVIDER); }
    private val cipher by lazy { Cipher.getInstance(TRANSFORMATION); }
    private val keyStore by lazy { KeyStore.getInstance(PROVIDER).apply { load(null); }; }

keyGenerator : KeyGenerator.getInstance(ALGORITHM, PROVIDER)

• “Give me a KeyGenerator for AES, and let it be backed by AndroidKeyStore.”
• This generator knows how to create a key that lives inside Keystore (non-exportable).

cipher

• Cipher.getInstance(TRANSFORMATION)
• “Give me a Cipher configured for AES/CBC/PKCS7.”
• We’ll reuse this cipher for encrypt/decrypt

keyStore

• KeyStore.getInstance(PROVIDER)
• Give me the Android keystore as a KeyStore object.”
• load(null): Initializes the keystore so we can read/write keys by alias.

actual fun encrypt(bytes: ByteArray): ByteArray {
    cipher.init(Cipher.ENCRYPT_MODE, getKey())
    val iv = cipher.iv
    val encrypted = cipher.doFinal(bytes)
    return iv + encrypted
}

cipher.init(Cipher.ENCRYPT_MODE, getKey())

• Puts cipher in ENCRYPT_MODE using the secret key from getKey().
• For CBC mode, when you init in ENCRYPT_MODE, it will randomly generate an IV (because we set setRandomizedEncryptionRequired(true) later).

val iv = cipher.iv

• After initialization, cipher.iv contains the random IV it just generated.
• IV is required for decrypting later.

val encrypted = cipher.doFinal(bytes)

• This encrypts the input bytes.
• doFinal = process all data and finish encryption.

return iv + encrypted

• We prepend the IV to the ciphertext.
• Why? Because to decrypt, we must know the IV that was used.
• IV is not secret, only random. So we store it together with the ciphertext.

So encrypt() does:

Generate random IV → encrypt → return [IV][CIPHERTEXT] in one ByteArray.

actual fun decrypt(bytes: ByteArray): ByteArray {
    val iv = bytes.copyOfRange(0, cipher.blockSize)
    val data = bytes.copyOfRange(cipher.blockSize, bytes.size)
    cipher.init(Cipher.DECRYPT_MODE, getKey(), IvParameterSpec(iv))
    return cipher.doFinal(data)
}

We expect the input bytes to be: [IV][CIPHERTEXT].

val iv = bytes.copyOfRange(0, cipher.blockSize

• AES block size = 16 bytes.
• Takes the first 16 bytes as the IV.

val data = bytes.copyOfRange(cipher.blockSize, bytes.size)

• Takes the rest of the bytes as the actual encrypted data.

cipher.init(Cipher.DECRYPT_MODE, getKey(), IvParameterSpec(iv))

• Now init cipher in DECRYPT_MODE.
• Use the same key (getKey()) and the extracted IV.
• IvParameterSpec(iv) tells the cipher which IV was originally used

return cipher.doFinal(data)

• Decrypts the data and returns the original plaintext.

So decrypt() does:

Split IV + ciphertext → initialize cipher with IV → decrypt → return plaintext.

Step 3 — IOS Implementation (iosMain)

the implementation in the ios side is not that straightforward and easy as in android especially when we need to implmenet it in Kotlin Native
we have 2 options

1- Write everything in the kotlin way ( iosMain) you will need to write it in lower level Objective-C

2- Write it in Swift side then call it directly in Kotlin using Interops

for that complexity i wrote the documentation inside the code

you can find it here
https://github.com/mohaberabi?tab=repositories

Step 3-A — IOS Implementation Using Kotlin

/**
 * this object does the logic with the native ios keychain
 * Generate 32-byte key (AES -256)
 * If we already have the key we return it
 * else we create a new random one and save it then return it
 *Stores data safely using iOS Security framework (SecItemAdd, SecItemCopyMatching)
 */
@OptIn(ExperimentalForeignApi::class)

object IosKryptoDelegate {
    private const val AES_KEY_SIZE_BYTES = 32

    val defaultKey by lazy { getOrCreateKey(); }

    /**
     *  If key already exists in Keychain → return it.
     *  If not → generate and save a new one.
     * So this gives you a stable AES key on this device.
     */
    private fun getOrCreateKey(): ByteArray {
        loadKey()?.let { return it }
        val newKey = generateRandomKey()
        saveKey(newKey)
        return newKey
    }

    /**
     *[kSecClass] type of item we are saving [kSecClassKey] means CRYPTO KEY
     *[kSecAttrApplicationTag] the tag of the data [AES_KEY_ALIAS] or Key Alias
     *[kSecValueData] the actual key that maps to the key we will use to save
     *[kSecAttrAccessible] the key that informs ios when to access the key
     *[kSecAttrAccessibleWhenUnlocked]Key is only available when the device is unlocked.
     */
    private fun saveKey(key: ByteArray) = memScoped {
        val keyData = key.toCFData() ?: return
        val tagData = AES_KEY_ALIAS.encodeToByteArray().toCFData() ?: return
        val dict = CFDictionaryCreateMutable(
            kCFAllocatorDefault,
            0,
            null,
            null
        ) ?: return
        CFDictionaryAddValue(dict, kSecClass, kSecClassKey)
        CFDictionaryAddValue(dict, kSecAttrApplicationTag, tagData)
        CFDictionaryAddValue(dict, kSecAttrAccessible, kSecAttrAccessibleWhenUnlocked)
        CFDictionaryAddValue(dict, kSecValueData, keyData)
        val status = SecItemAdd(dict, null)
        check(status == errSecSuccess || status == errSecDuplicateItem) {
            "SecItemAdd failed with status: $status"
        }
    }

    /**
     *[kSecClass] type of item we are saving [kSecClassKey] means CRYPTO KEY
     *[kSecAttrApplicationTag] the tag of the data [com.mohaberabi.krypto.krypto.AES_KEY_ALIAS] or Key Alias
     *[kSecValueData] the actual key that maps to the key we will use to save
     *[platform.Security.kSecReturnData] we are telling the Query to return the key
     *[platform.Security.kSecMatchLimitOne] Limit the result to exaclty one key only
     *Keychain reads output into a pointer.
     *Kotlin/Native requires a scoped memory region for this.
     * memScoped allocates temporary C memory for the duration of the block Automatically freed afterward.
     */
    private fun loadKey(): ByteArray? = memScoped {
        val tagData = AES_KEY_ALIAS.encodeToByteArray().toCFData()
        val query = CFDictionaryCreateMutable(
            allocator = kCFAllocatorDefault,
            capacity = 0,
            keyCallBacks = null,
            valueCallBacks = null
        ) ?: return@memScoped null
        CFDictionaryAddValue(query, kSecClass, kSecClassKey)
        CFDictionaryAddValue(query, kSecAttrApplicationTag, tagData)
        CFDictionaryAddValue(query, kSecReturnData, kCFBooleanTrue)
        CFDictionaryAddValue(query, kSecMatchLimit, kSecMatchLimitOne)
        val resultVar = alloc<CFTypeRefVar>()
        val status = SecItemCopyMatching(query, resultVar.ptr)
        if (status != errSecSuccess) return@memScoped null
        val cfData = resultVar.value
        if (cfData == null) return@memScoped null
        (cfData as CFDataRef).toByteArray()
    }

    /**
     *  Creates a 32-byte random array (AES-256).
     *  Each byte is random from 0–255.
     *  [usePinned]  --> read below to understand it
     *  kotlin native normally moves the arrays in memory but IOS needs
     *  a stable Pointer ( memory must not move)
     *  so the [usePinned] Pins the byteArray :
     *  it makes sure that memory address stays fixed during block is executed
     *  so after we are done we pass the pointer to IOS
     *  [addressOf] gives pointer to the index of the byte
     *  [NSData.create] creates an ios NSData object from the bytes
     *  [NSData] is exactly same as [ByteArray] in JVM
     *  at the end this is the key we will be using to store the data in IOS Chain
     *
     */

    fun generateRandomKey(): ByteArray = randomBytes(AES_KEY_SIZE_BYTES)

    fun randomBytes(length: Int): ByteArray {
        val array = ByteArray(length)
        array.usePinned { pinned ->
            val status = SecRandomCopyBytes(
                kSecRandomDefault,
                length.convert(),
                pinned.addressOf(0)
            )
            check(status == errSecSuccess) { "SecRandomCopyBytes failed: $status" }
        }
        return array
    }
}

@OptIn(ExperimentalForeignApi::class)
object KotlinNativeKrypto {
    private val AES_BLOCK_SIZE = kCCBlockSizeAES128.toInt()

    /**
     * UByteArray(BLOCK_SIZE.toInt()) { ... } → create an array of unsigned bytes of length 16.
     *  For each element: (0..255).random().toUByte() → generate random number 0–255, convert to UByte.
     *  toByteArray() → convert to normal ByteArray.
     *  Why IV?
     *  •  IV makes sure that encrypting the same data twice gives different ciphertext.
     *  •  Very important for security.
     *  •  IV is not secret, just random & unique.
     *  val encryptedBytes = ByteArray(bytes.size + BLOCK_SIZE.toInt())
     *      •  You allocate an array to hold the encrypted data.
     *  •  Its size is:
     *  •  original size bytes.size
     *  •  one extra block (16 bytes) to handle PKCS7 padding.
     *  •  AES with padding can produce up to input length + block size.
     *  op = [kCCEncrypt]Operation type. , kCCEncrypt means encrypt mode.
     *  alg = [kCCAlgorithmAES] the algorithm to encrypt with
     *  options = [kCCOptionPKCS7Padding] Use PKCS#7 padding, a standard padding method so data length can be a multiple of block size.
     *  key = [key.size]Pointer to the raw key bytes.
     *  •  key is NSData.
     *  •  key.bytes is like void* pointer to its bytes in memory.
     *   iv = [iv.refTo(0)] -Pointer to IV data - iv is a ByteArray. - iv.refTo(0) gives a C pointer to the first element.
     *   CommonCrypto uses IV to initialize the block cipher state.
     *   dataIn = bytes.refTo(0), bytes.size.convert()
     *   dataIn pointer → your plaintext data, first byte.
     *   bytes.size.convert() → number of bytes of input data.
     *  dataOut = encryptedBytes.refTo(0), encryptedBytes.size.convert()
     *  dataOut pointer → buffer where ciphertext will be written.
     *  encryptedBytes.size.convert() → maximum number of bytes it can write.
     *  dataOutMoved = outLength.ptr
     *  •  Pointer to your size_tVar variable.
     *  •  After the call, outLength.value will contain how many bytes of ciphertext were actually written.
     */
    fun encrypt(bytes: ByteArray): ByteArray {
        val key = IosKryptoDelegate.defaultKey
        val iv = IosKryptoDelegate.randomBytes(AES_BLOCK_SIZE)
        val outBuffer = ByteArray(bytes.size + AES_BLOCK_SIZE)
        var outLength = 0
        memScoped {
            val outLengthVar = alloc<size_tVar>()
            val status = key.usePinned { keyPinned ->
                iv.usePinned { ivPinned ->
                    bytes.usePinned { inPinned ->
                        outBuffer.usePinned { outPinned ->
                            CCCrypt(
                                op = kCCEncrypt,
                                alg = kCCAlgorithmAES,
                                options = kCCOptionPKCS7Padding,
                                key = keyPinned.addressOf(0),
                                keyLength = key.size.convert(),
                                iv = ivPinned.addressOf(0),
                                dataIn = inPinned.addressOf(0),
                                dataInLength = bytes.size.convert(),
                                dataOut = outPinned.addressOf(0),
                                dataOutAvailable = outBuffer.size.convert(),
                                dataOutMoved = outLengthVar.ptr
                            )
                        }
                    }
                }
            }

            if (status != kCCSuccess) {
                return bytes
            }
            outLength = outLengthVar.value.toInt()
        }

        val cipher = outBuffer.copyOf(outLength)
        return iv + cipher
    }

    fun decrypt(bytes: ByteArray): ByteArray {
        if (bytes.size <= AES_BLOCK_SIZE) return bytes
        val key = IosKryptoDelegate.defaultKey
        val iv = bytes.copyOfRange(0, AES_BLOCK_SIZE)
        val cipher = bytes.copyOfRange(AES_BLOCK_SIZE, bytes.size)
        val outBuffer = ByteArray(cipher.size + AES_BLOCK_SIZE)
        var outLength: Int = 0

        memScoped {
            val outLengthVar = alloc<size_tVar>()
            val status = key.usePinned { keyPinned ->
                iv.usePinned { ivPinned ->
                    cipher.usePinned { inPinned ->
                        outBuffer.usePinned { outPinned ->
                            CCCrypt(
                                op = kCCDecrypt,
                                alg = kCCAlgorithmAES,
                                options = kCCOptionPKCS7Padding,
                                key = keyPinned.addressOf(0),
                                keyLength = key.size.convert(),
                                iv = ivPinned.addressOf(0),
                                dataIn = inPinned.addressOf(0),
                                dataInLength = cipher.size.convert(),
                                dataOut = outPinned.addressOf(0),
                                dataOutAvailable = outBuffer.size.convert(),
                                dataOutMoved = outLengthVar.ptr
                            )
                        }
                    }
                }
            }
            if (status != kCCSuccess) {
                return bytes
            }
            outLength = outLengthVar.value.toInt()
        }
        return outBuffer.copyOf(outLength)
    }
}

Step 3-B — IOS Implementation Using Swift

import Foundation
import Security
import CommonCrypto

@objcMembers
public class IosKrypto: NSObject {

    private static let keyAlias = "com.mohaberabi.krypto.aesKey"
    private static let keyLength = 32 // 32 bytes => AES-256

    // MARK: - Public API

    private static func getOrCreateKey() -> Data? {
        if let existing = loadKey() {
            return existing
        }
        guard let key = generateRandomKey() else { return nil }
        saveKey(key)   
        return key
    }

    /// Encrypts data using AES/CBC/PKCS7.
    /// Returns [IV (16 bytes)] + [ciphertext]
    public static func encrypt(_ plain: Data) -> Data? {
        guard let key = getOrCreateKey() else { return nil }

        // 1) Random IV
        var iv = Data(count: kCCBlockSizeAES128)
        let ivStatus = iv.withUnsafeMutableBytes { ivBytes in
            guard let base = ivBytes.baseAddress else { return errSecParam }
            return SecRandomCopyBytes(
                kSecRandomDefault,
                kCCBlockSizeAES128,
                base
            )
        }
        if ivStatus != errSecSuccess { return nil }

        // 2) Encrypt
        let cryptLength = plain.count + kCCBlockSizeAES128
        var cryptData = Data(count: cryptLength)
        var numBytesEncrypted: size_t = 0

        let status = cryptData.withUnsafeMutableBytes { cryptBytes in
            iv.withUnsafeBytes { ivBytes in
                plain.withUnsafeBytes { plainBytes in
                    key.withUnsafeBytes { keyBytes in
                        CCCrypt(
                            CCOperation(kCCEncrypt),
                            CCAlgorithm(kCCAlgorithmAES),
                            CCOptions(kCCOptionPKCS7Padding),
                            keyBytes.baseAddress, key.count,
                            ivBytes.baseAddress,
                            plainBytes.baseAddress, plain.count,
                            cryptBytes.baseAddress, cryptLength,
                            &numBytesEncrypted
                        )
                    }
                }
            }
        }

        guard status == kCCSuccess else { return nil }

        // Trim output to actual size
        cryptData.removeSubrange(numBytesEncrypted..<cryptData.count)

        // 3) Return IV + ciphertext
        var result = Data()
        result.append(iv)
        result.append(cryptData)
        return result
    }

    /// Decrypts [IV (16 bytes)] + [ciphertext]
    public static func decrypt(_ cipher: Data) -> Data? {
        guard cipher.count > kCCBlockSizeAES128 else { return nil }
        guard let key = getOrCreateKey() else { return nil }

        let iv = cipher.subdata(in: 0..<kCCBlockSizeAES128)
        let encrypted = cipher.subdata(in: kCCBlockSizeAES128..<cipher.count)

        var decryptedData = Data(count: encrypted.count + kCCBlockSizeAES128)
        let decryptedLength = decryptedData.count      
        var numBytesDecrypted: size_t = 0

        let status = decryptedData.withUnsafeMutableBytes { decryptedBytes in
            iv.withUnsafeBytes { ivBytes in
                encrypted.withUnsafeBytes { encBytes in
                    key.withUnsafeBytes { keyBytes in
                        CCCrypt(
                            CCOperation(kCCDecrypt),
                            CCAlgorithm(kCCAlgorithmAES),
                            CCOptions(kCCOptionPKCS7Padding),
                            keyBytes.baseAddress, key.count,
                            ivBytes.baseAddress,
                            encBytes.baseAddress, encrypted.count,
                            decryptedBytes.baseAddress, decryptedLength, 
                            &numBytesDecrypted
                        )
                    }
                }
            }
        }

        guard status == kCCSuccess else { return nil }

        decryptedData.removeSubrange(numBytesDecrypted..<decryptedData.count)
        return decryptedData
    }
    

    // MARK: - Key / Keychain internals

    private static func generateRandomKey() -> Data? {
        var data = Data(count: keyLength)
        let status = data.withUnsafeMutableBytes { bytes in
            guard let base = bytes.baseAddress else { return errSecParam }
            return SecRandomCopyBytes(kSecRandomDefault, keyLength, base)
        }
        return (status == errSecSuccess) ? data : nil
    }

    private static func saveKey(_ key: Data) {
        guard let tag = keyAlias.data(using: .utf8) else { return }

        let query: [String: Any] = [
            kSecClass as String: kSecClassKey,
            kSecAttrApplicationTag as String: tag,
            kSecAttrAccessible as String: kSecAttrAccessibleWhenUnlocked,
            kSecValueData as String: key
        ]

        SecItemDelete(query as CFDictionary)
        SecItemAdd(query as CFDictionary, nil)
    }

    private static func loadKey() -> Data? {
        guard let tag = keyAlias.data(using: .utf8) else { return nil }

        let query: [String: Any] = [
            kSecClass as String: kSecClassKey,
            kSecAttrApplicationTag as String: tag,
            kSecReturnData as String: true,
            kSecMatchLimit as String: kSecMatchLimitOne,
        ]

        var item: CFTypeRef?
        let status = SecItemCopyMatching(query as CFDictionary, &item)
        guard status == errSecSuccess else { return nil }
        return item as? Data
    }
}

now the actual Object we can use any of the implementation inside

actual object Krypto {

    @OptIn(ExperimentalForeignApi::class)
    actual fun encrypt(bytes: ByteArray): ByteArray {
        if (bytes.isEmpty()) return byteArrayOf()
        return KotlinNativeKrypto.encrypt(bytes)
// or the IosKrypto from IOS Side 
    }

    @OptIn(ExperimentalForeignApi::class)
    actual fun decrypt(bytes: ByteArray): ByteArray {
        if (bytes.isEmpty()) return byteArrayOf()
        return KotlinNativeKrypto.decrypt(bytes)
// or the IosKrypto from IOS Side
    }
}

let’s try this code with simple app

@OptIn(ExperimentalEncodingApi::class)
@Composable
@Preview
fun App() {
    var text by remember {
        mutableStateOf("")
    }
    var encrypted by remember {
        mutableStateOf("")
    }
    var decrypted by remember {
        mutableStateOf("")
    }
    MaterialTheme {
        Scaffold { padding ->
            Column(
                horizontalAlignment = Alignment.CenterHorizontally,
                verticalArrangement = Arrangement.Center,
                modifier = Modifier.fillMaxSize()
                    .verticalScroll(rememberScrollState())
                    .padding(padding)
                    .padding(20.dp)
            ) {

                Spacer(Modifier.height(20.dp))
                TextField(
                    modifier = Modifier.fillMaxWidth(),
                    label = { Text("Type here your text") },
                    value = text,
                    onValueChange = { text = it },
                )

                Button(
                    onClick = {
                        encrypted = Krypto.encrypt(text)
                    },
                ) {
                    Text("Encrypt")
                }

                Text(
                    "Below is encrypted",
                    fontSize = 20.sp, fontWeight = FontWeight.Bold
                )
                Text(encrypted)
                Button(
                    onClick = {
                        decrypted = Krypto.decrypt(encrypted)
                    },
                ) {
                    Text("Decrypt")
                }
                Text(
                    "Below is decrypted",
                    fontSize = 20.sp,
                    fontWeight = FontWeight.Bold
                )
                Text(decrypted)
            }
        }
    }
}

Source Code: https://github.com/mohaberabi/krypto

Google’s BottomSheetNavigator is great — until you need it to work on Compose Multiplatform or Material 3 or you need to use the new type safe navigation in compose or compose multiplatform

So I reused something they already built (DialogNavigator) and turned it into a cross-platform, ViewModel-aware, type-safe BottomSheet navigation system

If you’ve used Navigation Compose, you know it supports:

composable(…)
dialog(…)

But what about bottom sheets?

You’ll quickly find accompanist-navigation-material — a Google library that adds:

bottomSheet("route") { … }

Sounds perfect, right?

Except it:

• Works only on Android
• Doesn’t compile in compose multiplatform
• Doesn’t support type safe
• Adds an extra Navigator and internal state logic which add the end exactly same as you show a modal bottom sheet inside a composable function , too many code and logic for a problem that was already solved

at our company our product which is a very complex POS Android app which is also Compose Multiplatform our design depends alot on bottom sheets , too many bottom sheets more than 90 bottom sheets where each one needs and does alot of business logic handles alot of events holds huge states , it was a hell to to nest all the sheets with all the data it needs inside the composable screen that needs to show or open it ,

While reading the Navigation Compose source, I realized something:

The dialog() destination already gives you a fully scoped backstack entry, lifecycle, and ViewModel store.

which means we can deal with it as if it was a screen isolated away from any other screens , viewmodel, savedStateHandle ,

and since the dialog() is an overlay component which still allows us to see the previous screen content while dialog is open , doesn’t it ring a bell ?

yes … the bottom sheet has the same exact behavior , the dialog<T>()

does not care or even know of what content it carry it just needs a composable function that can be composed and scoped to backStack and if a viewmodel is attached to it , it also clears it when the route which is the dialog (bottomSheet) is popped from the backstack ,

so it doesn’t matter if we added a scaffold , dialogue , column , card or even a ModalBottomSheet…..

That’s everything a bottom sheet needs — except for the UI.

So I thought:

“Why not reuse the dialog() destination, but display a bottom sheet instead?”

Here’s what I ended up writing:

import androidx.compose.runtime.Composable
import androidx.compose.ui.window.DialogProperties
import androidx.navigation.NamedNavArgument
import androidx.navigation.NavBackStackEntry
import androidx.navigation.NavDeepLink
import androidx.navigation.NavGraphBuilder
import androidx.navigation.NavType
import androidx.navigation.compose.DialogNavigator
import androidx.navigation.compose.DialogNavigatorDestinationBuilder
import androidx.navigation.compose.composable
import androidx.navigation.compose.dialog
import androidx.navigation.get
import kotlin.jvm.JvmSuppressWildcards
import kotlin.reflect.KClass
import kotlin.reflect.KType

data class BottomSheetProperties(
    val dismissOnBackPress: Boolean = true,
    val dismissOnClickOutside: Boolean = true,
    val usePlatformDefaultWidth: Boolean = true,
)


fun BottomSheetProperties.toDialogProperties() = DialogProperties(
    dismissOnBackPress = dismissOnBackPress,
    dismissOnClickOutside = dismissOnClickOutside,
    usePlatformDefaultWidth = usePlatformDefaultWidth
)

fun NavGraphBuilder.bottomSheet(
    route: String,
    arguments: List<NamedNavArgument> = emptyList(),
    deepLinks: List<NavDeepLink> = emptyList(),
    bottomSheetProperties: BottomSheetProperties = BottomSheetProperties(),
    content: @Composable (NavBackStackEntry) -> Unit
) {
    destination(
        navDestination = DialogNavigatorDestinationBuilder(
            navigator = provider[DialogNavigator::class],
            route = route,
            dialogProperties = bottomSheetProperties.toDialogProperties(),
            content = content
        ).apply {
            arguments.forEach { (argumentName, argument) -> argument(argumentName, argument) }
            deepLinks.forEach { deepLink -> deepLink(deepLink) }
        }
    )
}


inline fun <reified T : Any> NavGraphBuilder.bottomSheet(
    typeMap: Map<KType, @JvmSuppressWildcards NavType<*>> = emptyMap(),
    deepLinks: List<NavDeepLink> = emptyList(),
    bottomSheetProperties: BottomSheetProperties = BottomSheetProperties(),
    noinline content: @Composable (NavBackStackEntry) -> Unit
) {
    dialog(
        route = T::class,
        typeMap = typeMap,
        deepLinks = deepLinks,
        dialogProperties = bottomSheetProperties.toDialogProperties(),
        content = content
    )
}

fun <T : Any> NavGraphBuilder.bottomSheet(
    route: KClass<T>,
    typeMap: Map<KType, @JvmSuppressWildcards NavType<*>> = emptyMap(),
    deepLinks: List<NavDeepLink> = emptyList(),
    bottomSheetProperties: BottomSheetProperties = BottomSheetProperties(),
    content: @Composable (NavBackStackEntry) -> Unit
) {
    destination(
        DialogNavigatorDestinationBuilder(
            provider[DialogNavigator::class],
            route = route,
            typeMap = typeMap,
            dialogProperties = bottomSheetProperties.toDialogProperties(),
            content = content
        ).apply { deepLinks.forEach { deepLink -> deepLink(deepLink) } }
    )
}

let’s create a simple navigation flow

first inside your .toml file add

kotlinx-serialization = "1.9.0"
navigation-compose = "2.9.0"

[libraries]
....
navigation-compose = { module = "org.jetbrains.androidx.navigation:navigation-compose", version.ref = "navigation-compose" }
kotlinx-serialization = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json", name = "kotlinx-serialization", version.ref = "kotlinx-serialization" }

[plugins]
....
serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }

and inside your .kts file

plugins {
     ......
    alias(libs.plugins.serialization)

}
sourceSets {
 .... 
    commonMain.dependencies {
           ....
        implementation(libs.navigation.compose)
    }

}

@Serializable
data object HomeRoute

@Composable
fun HomeScreen(
    onGoCounter: () -> Unit
) {
    Scaffold { padding ->
        Column(
            modifier = Modifier.fillMaxSize()
                .padding(padding)
                .padding(20.dp),
            horizontalAlignment = Alignment.CenterHorizontally,
            verticalArrangement = Arrangement.Center
        ) {


            Button(
                onClick = onGoCounter,
            ) {
                Text("Go to counter")
            }
        }
    }
}

@Serializable
data class CounterRoute(
    val initialCounter: Int = 0
)

@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun CounterBottomSheet(
    onDismiss: () -> Unit,
    viewModel: CounterViewModel = viewModel()
) {
    val counter by viewModel.counter.collectAsStateWithLifecycle()
    ModalBottomSheet(
        onDismissRequest = onDismiss
    ) {

        Column(
            horizontalAlignment = Alignment.CenterHorizontally,
            verticalArrangement = Arrangement.Center
        ) {

            Row(
                horizontalArrangement = Arrangement.Center,
                verticalAlignment = Alignment.CenterVertically,
                modifier = Modifier.fillMaxWidth().padding(36.dp)
            ) {
                TextButton(
                    onClick = { viewModel.decrement() },
                ) {
                    Text("Decrement")
                }
                Text(
                    counter.toString(),
                    style = TextStyle(
                        fontSize = 20.sp,
                        fontWeight = FontWeight.Bold
                    )
                )
                TextButton(
                    onClick = { viewModel.increment() },
                ) {
                    Text("Increment")
                }
            }
        }
    }
}

class CounterViewModel(
    savedStateHandle: SavedStateHandle
) : ViewModel() {

    private val route = savedStateHandle.toRoute<CounterRoute>()


    private val _counter = MutableStateFlow(route.initialCounter)
    val counter = _counter.asStateFlow()


    fun increment() = _counter.update { it + 1 }
    fun decrement() = _counter.update { it - 1 }
}

@Composable
@Preview
fun App() {
    MaterialTheme {

        val navController = rememberNavController()
        NavHost(
            navController = navController,
            startDestination = HomeRoute,
        ) {
            composable<HomeRoute>() {
                HomeScreen(
                    onGoCounter = {
                        navController.navigate(CounterRoute(100))
                    },
                )
            }
            bottomSheet<CounterRoute>() {
                CounterBottomSheet(
                    onDismiss = navController::popBackStack,
                )
            }
        }

    }
}

• Creates a dedicated NavBackStackEntry
• Provides a ViewModelStoreOwner
• Manages dismissal and lifecycle
• Works everywhere Compose runs

All I did was replace the dialog UI with a bottom sheet surface.

Everything else — state, lifecycle, navigation — came for free.

Beyond Bottom Sheets

Because it’s just a dialog() extension, you can:

• Create custom pop-ups, snacker, or anything as destinations
• Pass args safely (dialog<T>(…))

This is the same “pattern reuse” mindset that makes Compose so powerful.

source code :

GitHub - mohaberabi/cmp-bottom-sheets-navigation: a simple app shows using bottom sheets navigation in compose multiplatform

if you want to see how to test a viewmodel with SavedStateHandle in compose multiplatform

Unit Testing ViewModels With SavedStateHandle In KMP

If you’ve ever unit-tested a ViewModel that reads its navigation arguments from SavedStateHandle, you’ve probably run into this:

Method putInt in android.os.BaseBundle not mocked.
See https://developer.android.com/r/studio-ui/build/not-mocked for details.

The setup

I’m using Compose Navigation with Kotlinx Serialization and a custom NavType to pass complex types.

@Serializable data object HomeScreenRoute

@Serializable data class FavoriteItem(val id: String, val name: String)

@Serializable
data class ComplexScreenRoute(
    val name: String,
    val id: String,
    val age: Int,
    val weight: Double,
    val favorites: List<FavoriteItem>
)

NavHost with a strongly-typed route

@Composable
fun AppNavHost(navController: NavHostController = rememberNavController()) {
    NavHost(startDestination = HomeScreenRoute, navController = navController) {
        composable<HomeScreenRoute> {
            HomeScreen(
                onGoComplexScreen = {
                    val route = ComplexScreenRoute(
                        name = "kotlin",
                        id = "kt",
                        age = 27,
                        weight = 75.5,
                        favorites = listOf(
                            FavoriteItem("1", "compose"),
                            FavoriteItem("2", "coroutines"),
                        )
                    )
                    navController.navigate(route)
                }
            )
        }

        composable<ComplexScreenRoute>(
            typeMap = mapOf(createNavTypePair<List<FavoriteItem>>())
        ) {
            ComplexScreen()
        }
    }
}

CustomNavType for lists (serialize/deserialize)

val navigationJson = Json {
    encodeDefaults = true
    ignoreUnknownKeys = true
    explicitNulls = false
}

inline fun <reified T> createNavTypePair(type: NavType<T> = createAppNavType<T>()) =
    typeOf<T>() to type

inline fun <reified T> createAppNavType(allowNulls: Boolean = false) =
    object : NavType<T>(isNullableAllowed = allowNulls) {
        override fun put(bundle: SavedState, key: String, value: T) {
            bundle.write { putString(key, navigationJson.encodeToString(value)) }
        }
        override fun get(bundle: SavedState, key: String): T? =
            bundle.read { navigationJson.decodeFromString(getString(key)) }
        override fun parseValue(value: String): T =
            navigationJson.decodeFromString(value)
        override fun serializeAsValue(value: T): String =
            navigationJson.encodeToString(value)
    }

The ViewModel (the “classic” approach)

class ComplexViewModel(
    private val savedStateHandle: SavedStateHandle
) : ViewModel() {

    val route: ComplexScreenRoute =
        savedStateHandle.toRoute(
            typeMap = mapOf(createNavTypePair<List<FavoriteItem>>())
        )
}

Koin wiring

val appModule = module {
 viewModelOf(::ComplexViewModel)
}

now let’s make use of the route we passed to the viewmodel

@Composable
fun ComplexScreen(viewModel: ComplexViewModel = koinViewModel()) {
 val r = viewModel.route
 Text("Name: ${r.name}")
 Text("Age: ${r.age}")
 Text("Weight: ${r.weight}")
 Text("Favorites:"); r.favorites.forEach { Text(it.name) }
}

now let’s run the app , but make sure you configured Koin for both IOS & Android

fun initKoin(config: KoinAppDeclaration? = null) {
    startKoin {
        config?.invoke(this)
        modules(
            appModule
        )
    }
}

class ComplexApp : Application() {

    override fun onCreate() {
        super.onCreate()
        initKoin {
            androidContext(this@ComplexApp)
        }
    }
}

fun MainViewController() = ComposeUIViewController(
    configure = {
        initKoin()
    }
) { App() }

@Composable
@Preview
fun App() {
    MaterialTheme {
        AppNavHost(

        )
    }
}

now run the app and naviagate

let’s now try to test the viewmdel

class ComplexViewModelTest {


    private lateinit var viewModel: ComplexViewModel
    private val savedStateHandle = SavedStateHandle()

    private val savedState = savedState {
        putInt("age", 1)
        putDouble("weight", 1.5)
    }

    @BeforeTest
    fun setup() {
        viewModel = ComplexViewModel(
            savedStateHandle = savedStateHandle
        )
    }


    @Test
    fun ` test args passed correct`() {
        val route = viewModel.route
        assertEquals(1, route.age)
    }

}

now after you run the tests

Method putInt in android.os.BaseBundle not mocked.
See https://developer.android.com/r/studio-ui/build/not-mocked for details.

that’s because savedStateHandle uses Android Bundle which needs an android tests , or to mock it but we can solve it to run it in commonTests

let’s create our interface with it’s implementation

/**
 * works only if used inside a viewmodel , do not exepct it to work outside a viewmodel or outside a place
 * that is not scoped to navGraph that uses [SavedStateHandle]
 * made to allow us to abstract the usage of navigation args provider
 * to make us not depend on Android OS Bundle which is hard to be mocked during tests
 * for the viewmodels that depends on [SavedStateHandle]
 */
interface NavArgsProvider {
    fun <T : Any> provideArg(
        route: KClass<T>,
        typeMap: Map<KType, @JvmSuppressWildcards NavType<*>> = emptyMap(),
    ): T

    /**
     * for debugging to make sure that [org.koin.core.Koin] provides exactly
     * same instance of [SavedStateHandle] scoped to the viewmodel that depends on [NavArgsProvider]
     *     private fun test() {
     *       val sameRef = ViewModel.savedStateHandle === navArgsProvider.provideOriginalHandle()
     *         println(sameStateRef) true
     *         val sameInstance = ViewModel.savedStateHandle == navArgsProvider.provideOriginalHandle()
     *         println(sameStateInst) true
     *     }
     */
    fun provideOriginalHandle(): SavedStateHandle
}

class DefaultNavArgsProvider(
    private val savedStateHandle: SavedStateHandle
) : NavArgsProvider {
    override fun <T : Any> provideArg(
        route: KClass<T>,
        typeMap: Map<KType, @JvmSuppressWildcards NavType<*>>
    ): T {
        return savedStateHandle.toRoute(route = route)
    }

    override fun provideOriginalHandle(): SavedStateHandle {
        return savedStateHandle
    }
}

it’s very simple method to provide the nav args but the trick here is how we will get the SavedStateHandle and also the same one that is attached to the current viewmodel instance , thanks to Koin which is navigation and viewmodel lifecycle aware by default which creates the SavedStateHandle Automatically to the current ViewModel at Runtime

1. Navigation/Compose creates a ViewModelStoreOwner per destination (usually the current NavBackStackEntry).
2. AndroidX builds a SavedStateHandle tied to that owner (so it survives config changes/process death).
3. Koin’s viewModel { … } factory plugs into the same ViewModelProvider pipeline, optionally receiving that SavedStateHandle as a parameter.
4. From inside your viewModel block, you can forward the exact same SavedStateHandle to any dependency (like DefaultNavArgsProvider) by calling get { parametersOf(state) }.
5. Your ViewModel then depends on NavArgsProvider (not on Android classes), keeping tests JVM-only.

val appModule = module {
    viewModelOf(::ComplexViewModel)
    factoryOf(::DefaultNavArgsProvider).bind(NavArgsProvider::class)
}

here we are sure that Koin once see

factoryOf(::DefaultNavArgsProvider).bind(NavArgsProvider::class)

it will look for it in the dependency graph , but we did not inject it … yes but once the NavArgsProvider is needed means that it is needed by ComplexViewModel … which is now alive with it’s SavedStateHandle so koin will take this instance and provide it to our DefaultNavArgsProvider

class ComplexViewModel(
    private val navArgsProvider: NavArgsProvider,
) : ViewModel() {


    val route = navArgsProvider.provideArg(
        route = ComplexScreenRoute::class,
        typeMap = mapOf(
            createNavTypePair<List<FavoriteItem>>()
        )
    )


}

now run the app and you will see nothing was changed we are still able to get the args and route inside the viewmodel and the screen

but let’s do a quick check to make sure we received same SavedStateHandle in our NavArgsProvider

package com.example.testingsavedstatehandle.viewmodel

import androidx.lifecycle.SavedStateHandle
import androidx.lifecycle.ViewModel
import androidx.navigation.toRoute
import com.example.testingsavedstatehandle.navigation.ComplexScreenRoute
import com.example.testingsavedstatehandle.navigation.DefaultNavArgsProvider
import com.example.testingsavedstatehandle.navigation.FavoriteItem
import com.example.testingsavedstatehandle.navigation.NavArgsProvider
import com.example.testingsavedstatehandle.navigation.createNavTypePair

class ComplexViewModel(
    private val navArgsProvider: NavArgsProvider,
    private val savedStateHandle: SavedStateHandle
) : ViewModel() {


    val route = navArgsProvider.provideArg(
        route = ComplexScreenRoute::class,
        typeMap = mapOf(
            createNavTypePair<List<FavoriteItem>>()
        )
    )


    init {
        test()
    }

    private fun test() {
        val sameRef = savedStateHandle === navArgsProvider.provideOriginalHandle()
        println("sameRef---${sameRef}")
        val sameContent = savedStateHandle == navArgsProvider.provideOriginalHandle()
        println("sameContent---${sameContent}")
    }
}

now remove all that debug code and let’s retest our viemwodel i will use a fake instance as for now , but you can also mock the object and pass it to the viewmodel

class ComplexViewModelTest {


    private lateinit var viewModel: ComplexViewModel
    private val fakeNavArgsProvider = object : NavArgsProvider {
        override fun <T : Any> provideArg(
            route: KClass<T>,
            typeMap: Map<KType, @JvmSuppressWildcards NavType<*>>
        ): T {
            return ComplexScreenRoute(
                name = "testpass",
                id = "testPassId",
                age = 1,
                weight = 1.5,
                favorites = listOf()
            ) as T
        }

        override fun provideOriginalHandle(): SavedStateHandle {
            TODO("Not yet implemented")
        }

    }

    @BeforeTest
    fun setup() {

        viewModel = ComplexViewModel(
            navArgsProvider = fakeNavArgsProvider
        )
    }


    @Test
    fun ` test args passed correct`() {
        val route = viewModel.route
        assertEquals("testpass", route.name)
    }

}

run tests and enjoy the green light
source code :

https://github.com/mohaberabi/savedstatehandle-testing-kmp

As mobile app development increasingly shifts toward cross-platform solutions, Kotlin Multiplatform (KMP) and Compose Multiplatform have become essential tools for developers. In this article, we’ll explore the native HTTP client built using Kotlin Multiplatform and Compose Multiplatform. This project is designed to provide seamless networking capabilities for Android and iOS using their specific implementation

let’s start by making the intrfaces and expect classes

in the common Source Set

create a domain pacakge and include the below classes

package com.mohaberabi.kmp.klient.domain.model

enum class ContentType(
    val value: String
) {
    Json("application/json"),
    TEXT("text/plain")
}

this is used for defining the request content type

package com.mohaberabi.kmp.klient.domain.model

enum class NetworkMethod {
    GET,
    DELETE,
    PUT,
    POST;

    val shouldAddBody: Boolean get() = this == POST || this == PUT
}

this is used for defining the request method name

package com.mohaberabi.kmp.klient.domain.model

data class NetworkResponse(
    val statusCode: Int,
    val headers: Map<String, String>,
    val body: String?,
)

a class encapsualtes the server response

package com.mohaberabi.kmp.klient.domain.model


data class NetworkingRequest(
    val url: String,
    val method: NetworkMethod,
    val headers: Map<String, String> = mapOf(),
    val body: String? = null,
    val params: Map<String, Any> = mapOf()
)

and this for the request model

package com.mohaberabi.kmp.klient.domain.model

data class NetworkingConfiguration(
    val connectionTimeOut: Int = 30 * 1000,
    val readTimeOut: Int = 30 * 1000,
    val contentType: ContentType = ContentType.Json
)

some configuration that might be useful when making requests

lets also make some class that we will expect it to be returned from servr for testing

package com.mohaberabi.kmp.klient.domain.model

data class PostModel(
    val title: String,
    val body: String,
    val userId: Int
)

now let’s start making the networking logic

package com.mohaberabi.kmp.klient.domain.source

import com.mohaberabi.kmp.klient.domain.model.NetworkResponse

interface Networking {


    suspend fun get(
        url: String,
        params: Map<String, Any> = mapOf(),
        headers: Map<String, String> = mapOf()
    ): NetworkResponse


    suspend fun post(
        url: String,
        headers: Map<String, String> = mapOf(),
        body: String? = null
    ): NetworkResponse

    suspend fun put(
        url: String,
        headers: Map<String, String> = mapOf(),
        body: String? = null
    ): NetworkResponse

    suspend fun delete(
        url: String,
        headers: Map<String, String> = mapOf(),
        queryParams: Map<String, Any> = emptyMap()
    ): NetworkResponse
}

we can also make our own interceptors , but a simple one for now

package com.mohaberabi.kmp.klient.domain.source

import com.mohaberabi.kmp.klient.domain.model.NetworkResponse
import com.mohaberabi.kmp.klient.domain.model.NetworkingRequest

interface NetworkInterceptor {
    suspend fun intercept(
        request: NetworkingRequest,
        chain: InterceptorChain,
    ): NetworkResponse
}

now we make the class that appends and processes the intercpetors

package com.mohaberabi.kmp.klient.domain.source

import com.mohaberabi.kmp.klient.domain.model.NetworkResponse
import com.mohaberabi.kmp.klient.domain.model.NetworkingRequest

class InterceptorChain(
    private val interceptors: List<NetworkInterceptor>,
    private val index: Int,
    private val onReady: suspend (NetworkingRequest) -> NetworkResponse
) {

    suspend fun proceed(
        request: NetworkingRequest
    ): NetworkResponse {
        return if (index >= interceptors.size) {
            onReady(request)
        } else {
            val nextChain = InterceptorChain(
                interceptors = interceptors,
                index = index + 1,
                onReady = onReady
            )
            val nextInterceptor = interceptors[index]
            return nextInterceptor.intercept(request, nextChain)
        }

    }
}

this class will keep intercepting the request until no interceptors yet to process then we execute the suspend onReady() function that is actual pivot method of the class

we now make the clinet class for encapuslates the networking

package com.mohaberabi.kmp.klient.domain.source

import com.mohaberabi.kmp.klient.domain.model.NetworkResponse
import com.mohaberabi.kmp.klient.domain.model.NetworkingRequest


interface NetworkClient {
    suspend fun makeRequest(
        request: NetworkingRequest,
    ): NetworkResponse

    fun addInterceptor(
        interceptor: NetworkInterceptor,
    )
}

now lets make a class that we will make use of it to test the client we are making , it has nothing to do with networking logic we will implement it with the help of our client we will implement

package com.mohaberabi.kmp.klient.domain.source

import com.mohaberabi.kmp.klient.domain.model.PostModel

interface ApiPlayGround {

    suspend fun getPost(
        id: Int
    ): Result<PostModel>

    suspend fun addPost(
        post: PostModel
    ): Result<Unit>

    suspend fun deletePost(
        id: Int
    ): Result<Unit>
}

now lets make the platform specific expect classes

lets make the engine that each platform will use to make a remote requests

package com.mohaberabi.kmp.klient.platform

import com.mohaberabi.kmp.klient.domain.model.NetworkResponse
import com.mohaberabi.kmp.klient.domain.model.NetworkingRequest

expect class HttpEngine {
    suspend fun makeRequest(
        request: NetworkingRequest,
    ): NetworkResponse

}

we can also make a factory for it for ease of creating it

package com.mohaberabi.kmp.klient.platform

import com.mohaberabi.kmp.klient.domain.model.NetworkingConfiguration

expect class HttpEngineFactory() {
    fun create(
        config: NetworkingConfiguration,
    ): HttpEngine
}

lets make some logging to use it as logging interceptor as well

package com.mohaberabi.kmp.klient.platform

expect object AppLogger {
    fun e(tag: String, message: String, throwable: Throwable? = null)
    fun d(tag: String, message: String)
    fun i(tag: String, message: String)

}

for ease of use and because each has some encoding mechanism we will make a url builder for each of ios and android

package com.mohaberabi.kmp.klient.platform

expect fun buildUrl(
    url: String,
    params: Map<String, Any?> = mapOf(),
): String

now let us start implmenting the android part we will use the Java HttpUrlConnection for making requests as the engine for android ,

for both of androdi and ios it will be one function that makes any remote reequest get , post , delete …etc but we pass to it the type of the method we need to make and the required needed params for the method to be exectued we will also wrap them all inside of a suspended function to avoid blocking calls

Android Engine

package com.mohaberabi.kmp.klient.platform

import com.mohaberabi.kmp.klient.domain.model.NetworkResponse
import com.mohaberabi.kmp.klient.domain.model.NetworkingConfiguration
import com.mohaberabi.kmp.klient.domain.model.NetworkingRequest
import kotlinx.coroutines.suspendCancellableCoroutine
import java.net.HttpURLConnection
import java.net.URL
import kotlin.coroutines.cancellation.CancellationException
import kotlin.coroutines.resume
import kotlin.coroutines.resumeWithException

actual class HttpEngine(
    private val config: NetworkingConfiguration
) {
    actual suspend fun makeRequest(request: NetworkingRequest): NetworkResponse {
        return suspendCancellableCoroutine { continuation ->
            try {
                val method = request.method
                val headers = request.headers
                val body = request.body
                val url = request.url
                val connection = URL(url).openConnection() as HttpURLConnection
                connection.apply {
                    requestMethod = method.name
                    connectTimeout = config.connectionTimeOut
                    readTimeout = config.readTimeOut
                    headers.forEach { (key, value) ->
                        addRequestProperty(key, value)
                        if (body != null && method.shouldAddBody) {
                            doOutput = true
                            val encodedBody = body.encodeToByteArray()
                            outputStream.use { stream ->
                                stream.write(encodedBody)
                            }
                        }
                    }
                }

                val code = connection.responseCode
                val responseBody = connection.inputStream.bufferedReader().use { it.readText() }
                val responseHeaders = connection.headerFields.filterKeys { it != null }
                connection.disconnect()
                val response = NetworkResponse(
                    statusCode = code,
                    body = responseBody,
                    headers = responseHeaders.mapValues { it.value.joinToString { ", " } },
                )
                continuation.resume(response)
            } catch (e: Exception) {
                if (e is CancellationException) {
                    throw e
                }
                e.printStackTrace()
                continuation.resumeWithException(e)
            }

        }


    }


}

Android Engine Factory

package com.mohaberabi.kmp.klient.platform

import com.mohaberabi.kmp.klient.domain.model.NetworkingConfiguration

actual class HttpEngineFactory {
    actual fun create(
        config: NetworkingConfiguration,
    ): HttpEngine = HttpEngine(config)

}

Android Logger

package com.mohaberabi.kmp.klient.platform

import android.util.Log

actual object AppLogger {
    actual fun e(tag: String, message: String, throwable: Throwable?) {
        if (throwable != null) {
            Log.e(tag, message, throwable)
        } else {
            Log.e(tag, message)
        }
    }

    actual fun d(tag: String, message: String) {
        Log.d(tag, message)
    }

    actual fun i(tag: String, message: String) {
        Log.i(tag, message)
    }


}

Android Url Builder

package com.mohaberabi.kmp.klient.platform

actual fun buildUrl(
    url: String,
    params: Map<String, Any?>
): String {
    if (params.isEmpty()) return url
    val encodedParams = params.map { (key, value) ->
        "${key}=${value.toString().urlEncode()}"
    }.joinToString("&")
    return "$url?$encodedParams"

}

fun String.urlEncode(): String = java.net.URLEncoder.encode(this, "UTF-8")

now for IOS Part

IOS Engine

package com.mohaberabi.kmp.klient.platform

import com.mohaberabi.kmp.klient.domain.model.NetworkResponse
import com.mohaberabi.kmp.klient.domain.model.NetworkingConfiguration
import com.mohaberabi.kmp.klient.domain.model.NetworkingRequest
import com.mohaberabi.kmp.klient.utils.toNSData
import com.mohaberabi.kmp.klient.utils.toUtf8String
import kotlinx.coroutines.suspendCancellableCoroutine
import platform.Foundation.HTTPBody
import platform.Foundation.HTTPMethod
import platform.Foundation.NSHTTPURLResponse
import platform.Foundation.NSMutableURLRequest
import platform.Foundation.NSURL
import platform.Foundation.NSURLSession
import platform.Foundation.dataTaskWithRequest
import platform.Foundation.setValue
import kotlin.coroutines.resume
import kotlin.coroutines.resumeWithException

actual class HttpEngine(
    private val config: NetworkingConfiguration,
) {
    actual suspend fun makeRequest(request: NetworkingRequest): NetworkResponse {
        return suspendCancellableCoroutine { contintuation ->
            val url = request.url
            val nsUrl = NSURL.URLWithString(url)
                ?: run {
                    contintuation.resumeWithException(Exception("Url is badly formatted"))
                    return@suspendCancellableCoroutine
                }
            val nsRequest = NSMutableURLRequest.requestWithURL(nsUrl)
            nsRequest.apply {
                setTimeoutInterval((config.connectionTimeOut / 1000).toDouble())
                setAllowsCellularAccess(true)
                HTTPMethod = request.method.name
                request.headers.forEach { (key, value) ->
                    setValue(value = value, forHTTPHeaderField = key)
                }
                request.body?.let {
                    HTTPBody = request.body.encodeToByteArray().toNSData()
                }
            }
            val session = NSURLSession.sharedSession


            val task = session.dataTaskWithRequest(
                request = nsRequest,
                completionHandler = { data, response, error ->
                    if (error != null) {
                        contintuation.resumeWithException(
                            Throwable(
                                message = error.localizedDescription,
                                cause = Throwable(error.localizedFailureReason)
                            )
                        )
                        return@dataTaskWithRequest
                    }

                    val httpResponse = response as? NSHTTPURLResponse

                    val status = httpResponse?.statusCode?.toInt() ?: 500
                    val headers = httpResponse?.allHeaderFields?.entries?.associate {
                        it.key.toString() to it.value.toString()
                    }.orEmpty()
                    val body = data?.toUtf8String()
                    contintuation.resume(NetworkResponse(status, headers, body))
                },
            )
            task.resume()
        }


    }


}

IOS Engine Factory

package com.mohaberabi.kmp.klient.platform

import com.mohaberabi.kmp.klient.domain.model.NetworkingConfiguration

actual class HttpEngineFactory {
    actual fun create(
        config: NetworkingConfiguration,
    ): HttpEngine = HttpEngine(config)


}

Ios Url Builder

package com.mohaberabi.kmp.klient.platform

import platform.Foundation.*

actual fun buildUrl(
    url: String,
    params: Map<String, Any?>
): String {
    val components = NSURLComponents.componentsWithString(url) ?: return url

    if (params.isNotEmpty()) {
        val queryItems = params.map { (key, value) ->
            NSURLQueryItem(name = key, value = value?.toString())
        }
        components.queryItems = queryItems
    }

    return components.URL?.absoluteString ?: url
}

Ios Logger

package com.mohaberabi.kmp.klient.platform

import platform.Foundation.NSLog

actual object AppLogger {
    actual fun e(tag: String, message: String, throwable: Throwable?) {

        if (throwable != null) {
            NSLog("ERROR: [$tag] $message. Throwable: $throwable CAUSE ${throwable.cause}")
        } else {
            NSLog("ERROR: [$tag] $message")
        }
    }

    actual fun d(tag: String, message: String) {
        NSLog("DEBUG: [$tag] $message")
    }

    actual fun i(tag: String, message: String) {
        NSLog("INFO: [$tag] $message")
    }

}

now we have our engine for each platform lets go back again to our common code

we will need some serialization mechanism we could have used any kotlin serialization library but for simplicty and as the data is small we will make serializaion our own for ios and android using their specific tools

so lets make it a rule we serialize into and from a map

package com.mohaberabi.kmp.klient.platform


expect fun Map<String, Any?>.toJsonString(): String

for android we will use java json object it is straightforward and simple

package com.mohaberabi.kmp.klient.platform

import org.json.JSONArray
import org.json.JSONException
import org.json.JSONObject

actual fun Map<String, Any?>.toJsonString(): String {
    val jsonObject = JSONObject()
    forEach { (key, value) ->
        jsonObject.put(key, value)
    }
    return jsonObject.toString()
}


fun String.toJsonObject() = JSONObject(this)
fun <T> JSONObject.safeGet(
    default: T,
    block: JSONObject.() -> T,
): T {
    return try {
        block()
    } catch (e: JSONException) {
        default
    }
}


fun JSONArray.toList(): List<String> {
    val list = mutableListOf<String>()
    for (i in 0 until this.length()) {
        list.add(this.getString(i))
    }
    return list
}

we made an extension function safe get for null safe and avoiding excptions while parsing

ios has same mechanism but slightly different , ios has a class Dictionary wich is in the end a map

package com.mohaberabi.kmp.klient.platform

import com.mohaberabi.kmp.klient.utils.toUtf8String
import kotlinx.cinterop.ExperimentalForeignApi
import platform.Foundation.NSArray
import platform.Foundation.NSDictionary
import platform.Foundation.NSJSONSerialization
import platform.Foundation.NSMutableArray
import platform.Foundation.NSMutableDictionary
import platform.Foundation.NSNull
import platform.Foundation.setValue

@OptIn(ExperimentalForeignApi::class)
actual fun Map<String, Any?>.toJsonString(): String {
    val nsDictionary = this.toNSDictionary()
    val jsonData = NSJSONSerialization.dataWithJSONObject(nsDictionary, 0u, null)
    return jsonData?.toUtf8String() ?: throw Exception("Failed to serialize to JSON")
}

fun Map<String, Any?>.toNSDictionary(): NSDictionary {
    val dictionary = NSMutableDictionary()
    forEach { (key, value) ->
        val nsValue = when (value) {
            null -> NSNull()
            is String -> value
            is Number -> value
            is Boolean -> value
            is Map<*, *> -> (value as Map<String, Any?>).toNSDictionary()
            is List<*> -> (value as List<Any?>).toNSArray()
            else -> throw IllegalArgumentException("Unsupported type: ${value::class}")
        }
        dictionary.setValue(value = nsValue, forKey = key)
    }
    return dictionary
}

fun List<Any?>.toNSArray(): NSArray {
    val array = NSMutableArray()
    forEach { item ->
        val nsValue = when (item) {
            null -> NSNull()
            is String -> item
            is Number -> item
            is Boolean -> item
            is Map<*, *> -> (item as Map<String, Any?>).toNSDictionary()
            is List<*> -> (item as List<Any?>).toNSArray()
            else -> throw IllegalArgumentException("Unsupported type: ${item::class}")
        }
        array.addObject(nsValue)
    }
    return array
}

and now we are ready to implment the networkign logic with serialization

lets create a class that accpets seerialization to be mapped to our class “Post”

package com.mohaberabi.kmp.klient.data

import com.mohaberabi.kmp.klient.domain.model.PostModel
import com.mohaberabi.kmp.klient.platform.toJsonString


data class PostDto(
    val title: String,
    val body: String,
    val userId: Int
)

fun PostDto.toPost() = PostModel(
    title, body, userId
)

fun PostModel.toPostRequestDto() = PostDto(
    title, body, userId
)

fun PostDto.toJson() = mapOf(
    "title" to title,
    "body" to body,
    "userId" to userId
).toJsonString()

we made a map of our class so we can be able to easy parse it

one last thing each one of the platforms will have it is own parsing logic

package com.mohaberabi.kmp.klient

import com.mohaberabi.kmp.klient.data.BookDto
import com.mohaberabi.kmp.klient.data.PostDto


expect fun String.toBookDto(): BookDto
expect fun String.toPostDto(): PostDto

Android Part

package com.mohaberabi.kmp.klient

import com.mohaberabi.kmp.klient.data.PostDto
import com.mohaberabi.kmp.klient.platform.safeGet
import com.mohaberabi.kmp.klient.platform.toJsonObject


actual fun String.toPostDto(): PostDto {
    val json = toJsonObject()
    val title = json.safeGet("unknown") { getString("title") }
    val body = json.safeGet("unknown") { getString("body") }
    val userId = json.safeGet(1) { getInt("userId") }
    return PostDto(title, body, userId)
}

Ios Part

package com.mohaberabi.kmp.klient

import com.mohaberabi.kmp.klient.data.PostDto
import com.mohaberabi.kmp.klient.utils.toNSData
import kotlinx.cinterop.ExperimentalForeignApi
import platform.Foundation.NSArray
import platform.Foundation.NSDictionary
import platform.Foundation.NSJSONReadingAllowFragments
import platform.Foundation.NSJSONSerialization
import platform.Foundation.valueForKey


fun <T> NSDictionary.safeGet(
    default: T,
    block: NSDictionary.() -> T?
): T {
    return try {
        block() ?: default
    } catch (e: Exception) {
        default
    }
}


@OptIn(ExperimentalForeignApi::class)
actual fun String.toPostDto(): PostDto {
    val jsonData = this.encodeToByteArray().toNSData()
    val jsonObject = NSJSONSerialization.JSONObjectWithData(
        jsonData,
        NSJSONReadingAllowFragments,
        null
    ) as? NSDictionary ?: throw Exception("Invalid JSON format")
    val title = jsonObject.safeGet("unknown") { valueForKey("title") as? String }

    val body = jsonObject.safeGet("unknown") { valueForKey("body") as? String }
    val userId = jsonObject.safeGet(1) { valueForKey("userId") as? Int }


    return PostDto(title, body, userId)

}

back again to our common source set

networking implementation

package com.mohaberabi.kmp.klient.data

import com.mohaberabi.kmp.klient.platform.buildUrl
import com.mohaberabi.kmp.klient.domain.model.NetworkMethod
import com.mohaberabi.kmp.klient.domain.model.NetworkResponse
import com.mohaberabi.kmp.klient.domain.model.NetworkingRequest
import com.mohaberabi.kmp.klient.domain.source.NetworkClient
import com.mohaberabi.kmp.klient.domain.source.Networking


class DefaultNetworking(
    private val client: NetworkClient,
) : Networking {
    override suspend fun get(
        url: String,
        params: Map<String, Any>,
        headers: Map<String, String>
    ): NetworkResponse {
        val fullUrl = buildUrl(url, params)
        val request = NetworkingRequest(
            method = NetworkMethod.GET,
            url = fullUrl,
            headers = headers
        )
        return client.makeRequest(request)
    }

    override suspend fun post(
        url: String,
        headers: Map<String, String>,
        body: String?,
    ): NetworkResponse {
        val fullUrl = buildUrl(url)
        val request = NetworkingRequest(
            method = NetworkMethod.POST,
            url = fullUrl,
            headers = headers,
            body = body
        )
        return client.makeRequest(request)
    }

    override suspend fun put(
        url: String,
        headers: Map<String, String>,
        body: String?,
    ): NetworkResponse {
        val fullUrl = buildUrl(url)
        val request = NetworkingRequest(
            method = NetworkMethod.PUT,
            url = fullUrl,
            headers = headers,
            body = body
        )
        return client.makeRequest(request)
    }

    override suspend fun delete(
        url: String,
        headers: Map<String, String>,
        queryParams: Map<String, Any>
    ): NetworkResponse {
        val fullUrl = buildUrl(url)
        val request = NetworkingRequest(
            method = NetworkMethod.DELETE,
            url = fullUrl,
            headers = headers,
        )
        return client.makeRequest(request)
    }


}

client impl

package com.mohaberabi.kmp.klient.data

import com.mohaberabi.kmp.klient.platform.HttpEngine
import com.mohaberabi.kmp.klient.domain.model.NetworkResponse
import com.mohaberabi.kmp.klient.domain.model.NetworkingRequest
import com.mohaberabi.kmp.klient.domain.source.InterceptorChain
import com.mohaberabi.kmp.klient.domain.source.NetworkClient
import com.mohaberabi.kmp.klient.domain.source.NetworkInterceptor

class DefaultNetworkingClient(
    private val engine: HttpEngine
) : NetworkClient {

    private val interceptors = mutableListOf<NetworkInterceptor>()
    override fun addInterceptor(interceptor: NetworkInterceptor) {
        interceptors.add(interceptor)
    }

    override suspend fun makeRequest(request: NetworkingRequest): NetworkResponse {
        val chain = InterceptorChain(
            interceptors = interceptors,
            index = 0,
            onReady = { engine.makeRequest(request) })
        return chain.proceed(request)

    }
}

now lets use our library to get , add , delete posts

package com.mohaberabi.kmp.klient.data

import com.mohaberabi.kmp.klient.domain.model.PostModel
import com.mohaberabi.kmp.klient.domain.source.ApiPlayGround
import com.mohaberabi.kmp.klient.domain.source.Networking
import com.mohaberabi.kmp.klient.toBookDto
import com.mohaberabi.kmp.klient.toPostDto
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.IO
import kotlinx.coroutines.withContext
import kotlin.coroutines.cancellation.CancellationException

class DefaultApiPlayground(
    private val networking: Networking,
) : ApiPlayGround {


    override suspend fun getPost(id: Int): Result<PostModel> {
        return withContext(Dispatchers.IO) {
            kotlin.runCatching {
                val response = networking.get("https://jsonplaceholder.typicode.com/posts/$id")
                val body = response.body ?: throw Exception("Response is null")
                val postDto = body.toPostDto()
                val post = postDto.toPost()
                post
            }.onFailure {
                if (it is CancellationException) {
                    throw it
                }
            }
        }
    }

    override suspend fun addPost(post: PostModel): Result<Unit> {

        return withContext(Dispatchers.IO) {
            kotlin.runCatching {
                val response = networking.post(
                    "https://jsonplaceholder.typicode.com/posts",
                    body = post.toPostRequestDto().toJson()
                )
            }.onFailure {
                if (it is CancellationException) {
                    throw it
                }
            }
        }
    }

    override suspend fun deletePost(id: Int): Result<Unit> {
        return kotlin.runCatching {
            val response = networking.delete(
                "https://jsonplaceholder.typicode.com/posts/${id}",
            )
        }.onFailure {
            if (it is CancellationException) {
                throw it
            }
        }

    }
}

let us also use our interceptor to add some interceptors to our chain

package com.mohaberabi.kmp.klient.data

import com.mohaberabi.kmp.klient.platform.AppLogger
import com.mohaberabi.kmp.klient.domain.model.ContentType
import com.mohaberabi.kmp.klient.domain.model.NetworkResponse
import com.mohaberabi.kmp.klient.domain.model.NetworkingRequest
import com.mohaberabi.kmp.klient.domain.source.InterceptorChain
import com.mohaberabi.kmp.klient.domain.source.NetworkInterceptor

class LoggingInterceptor : NetworkInterceptor {
    override suspend fun intercept(
        request: NetworkingRequest,
        chain: InterceptorChain
    ): NetworkResponse {
        AppLogger.d("LoggingInterceptor", "REQUEST:Url->${request.url}")
        AppLogger.d("LoggingInterceptor", "REQUEST:Body->${request.body}")
        AppLogger.d("LoggingInterceptor", "REQUEST:Headers->${request.headers}")
        AppLogger.d("LoggingInterceptor", "REQUEST:Params->${request.params}")
        val response = chain.proceed(request)
        AppLogger.d("LoggingInterceptor", "RESPONSE:Status->${response.statusCode}")
        AppLogger.d("LoggingInterceptor", "RESPONSE:Headers->${response.headers}")
        AppLogger.d("LoggingInterceptor", "RESPONSE:Body->${response.body}")
        return response
    }
}

class DefaultInterceptor(
    private val type: ContentType
) : NetworkInterceptor {
    override suspend fun intercept(
        request: NetworkingRequest,
        chain: InterceptorChain
    ): NetworkResponse {
        val headers = request.headers.toMutableMap()
        headers["Content-Type"] = type.value
        val newRequest = request.copy(headers = headers.toMap())
        return chain.proceed(newRequest)
    }
}

lets make some composbales sceen to test our app

package com.mohaberabi.kmp.klient

import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.material.Button
import androidx.compose.material.CircularProgressIndicator
import androidx.compose.material.Scaffold
import androidx.compose.material.Text

import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.rememberCoroutineScope
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.sp
import com.mohaberabi.kmp.klient.data.DefaultInterceptor
import com.mohaberabi.kmp.klient.data.DefaultNetworking
import com.mohaberabi.kmp.klient.data.DefaultNetworkingClient
import com.mohaberabi.kmp.klient.data.LoggingInterceptor
import com.mohaberabi.kmp.klient.data.DefaultApiPlayground
import com.mohaberabi.kmp.klient.domain.model.ContentType
import com.mohaberabi.kmp.klient.domain.model.NetworkingConfiguration
import com.mohaberabi.kmp.klient.domain.model.PostModel
import com.mohaberabi.kmp.klient.platform.AppLogger
import com.mohaberabi.kmp.klient.platform.HttpEngineFactory
import kotlinx.coroutines.launch

@Composable
fun HomeScreen(modifier: Modifier = Modifier) {

    val client = remember {
        DefaultNetworkingClient(
            HttpEngineFactory().create(
                NetworkingConfiguration(),
            )
        ).apply {
            addInterceptor(LoggingInterceptor())
            addInterceptor(DefaultInterceptor(ContentType.Json))
        }
    }
    val networking = remember {
        DefaultNetworking(client)
    }
    val source = remember {
        DefaultApiPlayground(networking)
    }
    var loading by remember {

        mutableStateOf(false)
    }
    var post by remember {
        mutableStateOf<PostModel?>(null)
    }

    val scope = rememberCoroutineScope()
    LaunchedEffect(
        key1 = Unit,
    ) {
        loading = true
        source.getPost(1)
            .onFailure {
                it.printStackTrace()
                loading = false
            }.onSuccess {
                post = it
                loading = false
            }

    }

    Scaffold { padding ->
        Column(
            modifier = modifier
                .fillMaxSize()
                .padding(padding),
            horizontalAlignment = Alignment.CenterHorizontally,
            verticalArrangement = Arrangement.Center
        ) {
            if (loading) {
                CircularProgressIndicator()
            } else {
                post?.let {
                    Text(text = "Post Found")
                    Text(
                        text = it.title,
                        fontSize = 20.sp,
                        textAlign = TextAlign.Center,
                        fontWeight = FontWeight.Bold
                    )
                } ?: Text(text = "Something Went Wrong")
            }


            Button(
                onClick = {
                    scope.launch {
                        source.addPost(PostModel("test", "test", 1))
                            .onFailure {
                                it.printStackTrace()
                            }.onSuccess { AppLogger.d("post", "Post Added") }
                    }
                },
            ) {
                Text("Add Post Test")
            }
            Button(
                onClick = {
                    scope.launch {
                        source.deletePost(111)
                            .onFailure {
                                it.printStackTrace()
                            }.onSuccess { AppLogger.d("post", "Post Deleted") }
                    }
                },
            ) {
                Text("Delete Post Test")
            }
        }
    }
}

import klient.composeapp.generated.resources.Res
import klient.composeapp.generated.resources.compose_multiplatform

@Composable
@Preview
fun App() {
    MaterialTheme {
        HomeScreen()
    }
}

Github Repository : https://github.com/mohaberabi/klient