Core/io.telereso.kmp.core

Package-level declarations

Types

A AndroidPlatform class that defines the Android platform type and name. References the names from the Android platform specific Build class

AppEventsObserver

open class AppEventsObserver(context: Context, capabilities: List<Int>, transportTypes: List<Int>) : DefaultLifecycleObserver

BrowserPlatform

class BrowserPlatform : Platform

A class we define platform specific or actual implementations for JS Target

CommonFlow

class CommonFlow<T>(val origin: Flow<T>) : Flow<T>

A wrapper class for Kotlin Coroutine Flows for iOS. This is picked up from jetbrain's kotlinconf FlowUtils. So instead of flow, we only have callbacks that looks almost like a flow, It also exposes a Closeable. that is responsible for closing any scope we have on Kotlin side. so client can simple call close(). this creates a lifecycle flow we can deal with. it enables iOS and web to consume the flow data in a natural way. refer to the iOS and web samples for how to use. launchIn defines where we running our coroutine. here its running on Dispatchers.Main so this may cause issue with Threading controlled on Kotlin KMM. e.g in case the client want to run this flow in a Dispatchers background it will still run on Main. but will explorer this some other time.

CompareResult

data class CompareResult(val match: Boolean, val differences: MutableList<Difference> = mutableListOf())

Config

@ExperimentalJsExport

class Config(val builder: Config.Builder)

All common config for client mangers

Consumer

data class Consumer(val platform: Platform.Type, val appId: String, val fingerprint: String? = null, val alg: String = DEFAULT_ALG)

ContextScope

class ContextScope(context: CoroutineContext) : CoroutineScope

CoreClient

actual class CoreClient

expect class CoreClient

actual class CoreClient

Difference

data class Difference(val obj1: String, val obj2: String, val path: String, val message: String)

DispatchersProvider

object DispatchersProvider

Environment

enum Environment : Enum<Environment>

Defines the different Environments the sdk support. this is usually passed to the SDK via the Config builder.

Flows

object Flows

Http

object Http

a singleton class that holds utils common to the Http.

InMemorySetting

class InMemorySetting(clearExpiredKeysDuration: Duration? = null) : Settings

class provides an in memory version of the settings, mostly useful during unit tests.

InternalTask

internal actual class InternalTask<ResultT>(_task: Task<ResultT>)

internal expect class InternalTask<ResultT>(_task: Task<ResultT>)

internal actual class InternalTask<ResultT>(_task: Task<ResultT>)

IOSPlatform

class IOSPlatform : Platform

Since the rest of the Darwin targets depend on iOSMain during its creation, All the actual implementations can be reuse and pickup from iOsMain On in special occasions when we need custom implementation on like MacOS or WatchOS we can use the specific target module.

JvmPlatform

class JvmPlatform : Platform

LazySuspend

class LazySuspend<T>(initializer: suspend () -> T)

https://github.com/Kotlin/kotlinx.coroutines/issues/706

Log

object Log

MapSettings

class MapSettings(val delegate: MutableMap<String, Any> = mutableMapOf(), clearExpiredKeysDuration: Duration? = null) : ObservableSettings

A collection of storage-backed key-value data

NodeJsPlatform

class NodeJsPlatform : Platform

ObservableSettings

interface ObservableSettings : Settings

A handle to a listener instance returned by one of the addListener methods of ObservableSettings, so it can be deactivated as needed.

Platform

abstract class Platform

Defines the supported platforms by the sdks

RunBlocking

@Target(allowedTargets = [AnnotationTarget.FUNCTION])

annotation class RunBlocking

Settings

interface Settings

A Wrapper for saving simple key-value data. Currently it only supports saving of primitive data types. TODO later we can add coroutines support or settings listeners since our implementation can support it. TODO later we can support wrapped using a property delegate.

SettingsImpl

internal class SettingsImpl(val settings: Settings = com.russhwolf.settings.Settings(), clearExpiredKeysDuration: Duration? = null) : Settings

https://github.com/russhwolf/multiplatform-settings

SqlDriverFactory

actual open class SqlDriverFactory(val databaseName: String, val asyncSchema: SqlSchema<QueryResult.AsyncValue<Unit>>)

expect open class SqlDriverFactory(databaseName: String, asyncSchema: SqlSchema<QueryResult.AsyncValue<Unit>>)

actual open class SqlDriverFactory(val databaseName: String, val asyncSchema: SqlSchema<QueryResult.AsyncValue<Unit>>)

Task

@ExperimentalJsExport

class Task<ResultT>(val scope: CoroutineScope, val config: TaskConfig? = TaskConfig(), block: suspend CoroutineScope.() -> ResultT)

A discriminated union that encapsulates a successful outcome with a value of type ResultT or a failure with an arbitrary Throwable ClientException.

TaskConfig

data class TaskConfig(val retry: Int? = 0, val backOffDelay: Int? = 0, val startDelay: Int? = 0, val timeout: Int? = null)

Tasks

object Tasks

TasksExamples

object TasksExamples

ThrowableSerializer

object ThrowableSerializer : KSerializer<Throwable>

ThrowableSerializer is a custom serializer for the Throwable class which is used to serialize/deserialize Throwable objects to/from json strings. This class implements the KSerializer interface provided by the kotlinx.serialization library.

TolerancePolicy

data class TolerancePolicy(val missingAsNull: Boolean = false, val decimalAsDouble: Boolean = false)

Functions

asCommonFlow

fun <T> Flow<T>.asCommonFlow(): CommonFlow<T>

await

suspend fun <ResultT> Task<ResultT>.await(): ResultT

Wait for the task to finish

awaitAll

suspend fun <ResultT> Array<Task<ResultT>>.awaitAll(): List<ResultT>

suspend fun <ResultT> List<Task<ResultT>>.awaitAll(): List<ResultT>

Wait for all tasks to finish

awaitOrNull

suspend fun <ResultT> Task<ResultT>.awaitOrNull(): ResultT?

Wait for the task to finish

awaitOrNullAll

suspend fun <ResultT> Array<Task<ResultT>>.awaitOrNullAll(): List<ResultT?>

suspend fun <ResultT> List<Task<ResultT>>.awaitOrNullAll(): List<ResultT?>

Wait for all tasks to finish

compare

fun JsonElement.compare(jsonElement: JsonElement, tolerate: TolerancePolicy = TolerancePolicy()): Boolean

compareCheck

fun JsonElement.compareCheck(jsonElement: JsonElement, tolerate: TolerancePolicy = TolerancePolicy(), printObjects: Boolean = false)

compareJson

fun compareJson(json1: JsonElement, json2: JsonElement, path: String = "", compareResult: CompareResult = CompareResult(false), tolerate: TolerancePolicy = TolerancePolicy()): CompareResult

compareJsonArrays

fun compareJsonArrays(compareResult: CompareResult, tolerate: TolerancePolicy, array1: JsonArray, array2: JsonArray, path: String): CompareResult

compareJsonObjects

fun compareJsonObjects(compareResult: CompareResult, tolerate: TolerancePolicy, obj1: JsonObject, obj2: JsonObject, path: String): CompareResult

compareJsonPrimitives

fun compareJsonPrimitives(compareResult: CompareResult, tolerate: TolerancePolicy, primitive1: JsonPrimitive, primitive2: JsonPrimitive, path: String): CompareResult

contains

inline operator fun Settings.contains(key: String): Boolean

Equivalent to Settings.hasKey

debugLogger

fun debugLogger()

Called from the client to initialize Napier logger

debugLoggerInternal

internal fun debugLoggerInternal()

destructiveMigrationSynchronous

fun SqlSchema<QueryResult.AsyncValue<Unit>>.destructiveMigrationSynchronous(): SqlSchema<QueryResult.Value<Unit>>

get

fun get(): CoreClient

Return Singleton CoreClient

get

inline operator fun <T : Any> Settings.get(key: String): T?

Get the typed value stored at key if present, or return null if not. Throws IllegalArgumentException if T is not one of Int, Long, String, Float, Double, or Boolean.

inline operator fun Settings.get(key: String, defaultValue: Boolean): Boolean

Equivalent to Settings.getBoolean

inline operator fun Settings.get(key: String, defaultValue: Double): Double

Equivalent to Settings.getDouble

inline operator fun Settings.get(key: String, defaultValue: Float): Float

Equivalent to Settings.getFloat

inline operator fun Settings.get(key: String, defaultValue: Int): Int

Equivalent to Settings.getInt

inline operator fun Settings.get(key: String, defaultValue: Long): Long

Equivalent to Settings.getLong

inline operator fun Settings.get(key: String, defaultValue: String): String

Equivalent to Settings.getString

getPlatform

actual fun getPlatform(): Platform

expect fun getPlatform(): Platform

expects implementation on all supported platforms

actual fun getPlatform(): Platform

expected Platform imlmentation for iOS platform

actual fun getPlatform(): Platform

expected Platform implementation for JS platform

actual fun getPlatform(): Platform

expected Platform implementation for JVM platform

httpClient

actual fun httpClient(shouldLogHttpRequests: Boolean, interceptors: List<Any?>?, userAgent: String?, config: HttpClientConfig<*>.() -> Unit): HttpClient

expect fun httpClient(shouldLogHttpRequests: Boolean = false, interceptors: List<Any?>? = listOf(), userAgent: String? = null, config: HttpClientConfig<*>.() -> Unit = {}): HttpClient

To configure Ktor engine-specific options in our multiplatform SDK we declare expect/actual dependencies Notice by default we set it to Unit we can also define this expect within the network package so not accessible to client. We have to write some actual and expected functions that will resolve all platform’s conflicts in iOS and Android and JS. It calls different HTTP functions in different platforms which you can define platform-specific.

actual fun httpClient(shouldLogHttpRequests: Boolean, interceptors: List<Any?>?, userAgent: String?, config: HttpClientConfig<*>.() -> Unit): HttpClient

actual declaration of the httpClient function for the iOS

actual fun httpClient(shouldLogHttpRequests: Boolean, interceptors: List<Any?>?, userAgent: String?, config: HttpClientConfig<*>.() -> Unit): HttpClient

initLogger

fun ~~initLogger~~()

Called from the client to initialize Napier logger

fun ~~initLogger~~()

Called from the client to initialize Napier logger

isSimulator

fun Platform.isSimulator(): Boolean

minusAssign

inline operator fun Settings.minusAssign(key: String)

Equivalent to Settings.remove

set

inline operator fun <T : Any> Settings.set(key: String, value: T?)

Stores a typed value at key, or remove what's there if value is null. Throws IllegalArgumentException if T is not one of Int, Long, String, Float, Double, or Boolean.

inline operator fun Settings.set(key: String, value: Boolean)

Equivalent to Settings.putBoolean

inline operator fun Settings.set(key: String, value: Double)

Equivalent to Settings.putDouble

inline operator fun Settings.set(key: String, value: Float)

Equivalent to Settings.putFloat

inline operator fun Settings.set(key: String, value: Int)

Equivalent to Settings.putInt

inline operator fun Settings.set(key: String, value: Long)

Equivalent to Settings.putLong

inline operator fun Settings.set(key: String, value: Nothing?)

Equivalent to Settings.remove

inline operator fun Settings.set(key: String, value: String)

Equivalent to Settings.putString

toNSError

fun ClientException.toNSError(): NSError

Converts a ClientException into an NSError object for better interop with Objective-C, Swift projects.

watch

fun <T> CommonFlow<T>.watch(stream: (T) -> Unit, error: (ClientException) -> Unit, scope: CoroutineScope = ContextScope.get(DispatchersProvider.Default)): CommonFlow.Job

Another way to consume common flows for JS ,