Update gradle.properties

0.0.18

.github/workflows/commit-publish.yml

@@ -7,7 +7,10 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions/setup-java@v1
         with:
-          java-version: 1.8
+          java-version: 11
+      - name: Fix android 32.0.0 dx
+        continue-on-error: true
+        run: cd /usr/local/lib/android/sdk/build-tools/32.0.0/ && mv d8 dx && cd lib  && mv d8.jar dx.jar
       - name: Update version
         run: |
           branch="`echo "${{ github.ref }}" | grep -o "[^/]*$"`"

.gitignore

@@ -11,5 +11,6 @@ out/
 
 secret.gradle
 local.properties
+kotlin-js-store/
 
 publishing.sh

build.gradle

@@ -1,6 +1,5 @@
 buildscript {
     repositories {
-        jcenter()
         google()
         mavenCentral()
         mavenLocal()
@@ -8,7 +7,7 @@ buildscript {
     }
 
     dependencies {
-        classpath 'com.android.tools.build:gradle:4.1.3'
+        classpath 'com.android.tools.build:gradle:7.0.4'
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
         classpath "org.jetbrains.kotlin:kotlin-serialization:$kotlin_version"
         classpath "com.getkeepsafe.dexcount:dexcount-gradle-plugin:$dexcount_version"
@@ -19,10 +18,8 @@ buildscript {
 allprojects {
     repositories {
         mavenLocal()
-        jcenter()
         mavenCentral()
         google()
-        maven { url "https://kotlin.bintray.com/kotlinx" }
     }
 }
 

cache/admins/micro_utils/src/commonMain/kotlin/dev/inmo/tgbotapi/libraries/cache/admins/micro_utils/DefaultAdminsCacheAPI.kt

@@ -51,12 +51,12 @@ class DefaultAdminsCacheAPIRepo(
     }
 
     override suspend fun getChatAdmins(chatId: ChatId): List<AdministratorChatMember>? = suspendCoroutine {
-        actor.offer(GetChatAdminsRepoAction(chatId, it))
+        actor.trySend(GetChatAdminsRepoAction(chatId, it))
     }
     override suspend fun setChatAdmins(chatId: ChatId, chatMembers: List<AdministratorChatMember>) = suspendCoroutine<Unit> {
-        actor.offer(SetChatAdminsRepoAction(chatId, chatMembers, it))
+        actor.trySend(SetChatAdminsRepoAction(chatId, chatMembers, it))
     }
     override suspend fun lastUpdate(chatId: ChatId): DateTime? = suspendCoroutine {
-        actor.offer(GetUpdateDateTimeRepoAction(chatId, it))
+        actor.trySend(GetUpdateDateTimeRepoAction(chatId, it))
     }
 }

cache/content/common/build.gradle

@@ -10,8 +10,9 @@ kotlin {
     sourceSets {
         commonMain {
             dependencies {
-                api project(":tgbotapi.libraries.fsm.core")
+                api "dev.inmo:tgbotapi.core:$tgbotapi_version"
             }
         }
     }
 }
+

cache/content/common/src/commonMain/kotlin/dev/inmo/tgbotapi/libraries/cache/media/common/DefaultMessageContentCache.kt

@@ -0,0 +1,135 @@
+package dev.inmo.tgbotapi.libraries.cache.media.common
+
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.requests.DeleteMessage
+import dev.inmo.tgbotapi.requests.DownloadFileStream
+import dev.inmo.tgbotapi.requests.abstracts.MultipartFile
+import dev.inmo.tgbotapi.requests.get.GetFile
+import dev.inmo.tgbotapi.requests.send.media.*
+import dev.inmo.tgbotapi.types.ChatId
+import dev.inmo.tgbotapi.types.InputMedia.*
+import dev.inmo.tgbotapi.types.message.content.abstracts.MediaContent
+import dev.inmo.tgbotapi.types.message.content.abstracts.MessageContent
+import dev.inmo.tgbotapi.utils.asInput
+import io.ktor.utils.io.core.Input
+
+class DefaultMessageContentCache<K>(
+    private val bot: TelegramBot,
+    private val filesRefreshingChatId: ChatId,
+    private val simpleMessageContentCache: MessagesSimpleCache<K>,
+    private val mediaFileActualityChecker: MediaFileActualityChecker = MediaFileActualityChecker.WithDelay(
+        MediaFileActualityChecker.Default(filesRefreshingChatId)
+    ),
+    private val messagesFilesCache: MessagesFilesCache<K> = InMemoryMessagesFilesCache()
+) : MessageContentCache<K> {
+    override suspend fun save(content: MessageContent): K {
+        return when (content) {
+            is MediaContent -> {
+                val extendedInfo = bot.execute(
+                    GetFile(content.media.fileId)
+                )
+                val allocator = bot.execute(
+                    DownloadFileStream(
+                        extendedInfo.filePath
+                    )
+                )
+
+                save(content, extendedInfo.fileName) {
+                    allocator.invoke().asInput()
+                }
+            }
+            else -> simpleMessageContentCache.add(content)
+        }
+    }
+
+    override suspend fun save(
+        content: MediaContent,
+        filename: String,
+        inputAllocator: suspend () -> Input
+    ): K {
+        val key = simpleMessageContentCache.add(content)
+        runCatching {
+            messagesFilesCache.set(key, filename, inputAllocator)
+        }.onFailure {
+            simpleMessageContentCache.remove(key)
+        }.onSuccess {
+            with(mediaFileActualityChecker) {
+                bot.saved(content)
+            }
+        }
+
+        return key
+    }
+
+    override suspend fun get(k: K): MessageContent? {
+        val savedSimpleContent = simpleMessageContentCache.get(k) ?: return null
+
+        if (savedSimpleContent is MediaContent && !with(mediaFileActualityChecker) { bot.isActual(savedSimpleContent) }) {
+            val savedFileContentAllocator = messagesFilesCache.get(k) ?: error("Unexpected absence of $k file for content ($simpleMessageContentCache)")
+            val newContent = bot.execute(
+                when (savedSimpleContent.asInputMedia()) {
+                    is InputMediaAnimation -> SendAnimation(
+                        filesRefreshingChatId,
+                        MultipartFile(
+                            savedFileContentAllocator
+                        ),
+                        disableNotification = true
+                    )
+                    is InputMediaAudio -> SendAudio(
+                        filesRefreshingChatId,
+                        MultipartFile(
+                            savedFileContentAllocator
+                        ),
+                        disableNotification = true
+                    )
+                    is InputMediaVideo -> SendVideo(
+                        filesRefreshingChatId,
+                        MultipartFile(
+                            savedFileContentAllocator
+                        ),
+                        disableNotification = true
+                    )
+                    is InputMediaDocument -> SendDocument(
+                        filesRefreshingChatId,
+                        MultipartFile(
+                            savedFileContentAllocator
+                        ),
+                        disableNotification = true
+                    )
+                    is InputMediaPhoto -> SendPhoto(
+                        filesRefreshingChatId,
+                        MultipartFile(
+                            savedFileContentAllocator
+                        ),
+                        disableNotification = true
+                    )
+                }
+            )
+
+            simpleMessageContentCache.update(k, newContent.content)
+            return newContent.content
+        }
+        return savedSimpleContent
+    }
+
+    override suspend fun contains(k: K): Boolean {
+        return simpleMessageContentCache.contains(k)
+    }
+
+    override suspend fun remove(k: K) {
+        simpleMessageContentCache.remove(k)
+        messagesFilesCache.remove(k)
+    }
+
+    companion object {
+        operator fun invoke(
+            bot: TelegramBot,
+            filesRefreshingChatId: ChatId,
+            simpleMessageContentCache: MessagesSimpleCache<String> = InMemoryMessagesSimpleCache(),
+            mediaFileActualityChecker: MediaFileActualityChecker = MediaFileActualityChecker.WithDelay(
+                MediaFileActualityChecker.Default(filesRefreshingChatId)
+            ),
+            messagesFilesCache: MessagesFilesCache<String> = InMemoryMessagesFilesCache()
+        ) = DefaultMessageContentCache(bot, filesRefreshingChatId, simpleMessageContentCache, mediaFileActualityChecker, messagesFilesCache)
+    }
+}

cache/content/common/src/commonMain/kotlin/dev/inmo/tgbotapi/libraries/cache/media/common/MediaFileActualityChecker.kt

@@ -0,0 +1,55 @@
+package dev.inmo.tgbotapi.libraries.cache.media.common
+
+import com.soywiz.klock.DateTime
+import com.soywiz.klock.milliseconds
+import dev.inmo.tgbotapi.bot.TelegramBot
+import dev.inmo.tgbotapi.requests.DeleteMessage
+import dev.inmo.tgbotapi.requests.abstracts.FileId
+import dev.inmo.tgbotapi.types.ChatId
+import dev.inmo.tgbotapi.types.MilliSeconds
+import dev.inmo.tgbotapi.types.message.content.abstracts.MediaContent
+
+fun interface MediaFileActualityChecker {
+    suspend fun TelegramBot.isActual(mediaContent: MediaContent): Boolean
+    suspend fun TelegramBot.saved(mediaContent: MediaContent) {}
+
+    class Default(
+        private val checkingChatId: ChatId
+    ) : MediaFileActualityChecker {
+        override suspend fun TelegramBot.isActual(mediaContent: MediaContent): Boolean {
+            return runCatching {
+                execute(mediaContent.createResend(checkingChatId)).also { sentMessage ->
+                    execute(DeleteMessage(sentMessage.chat.id, sentMessage.messageId))
+                }
+            }.isSuccess
+        }
+    }
+
+    class WithDelay(
+        private val underhoodChecker: MediaFileActualityChecker,
+        private val checkingDelay: MilliSeconds = 24 * 60 * 60 * 1000L // one day
+    ) : MediaFileActualityChecker {
+        private val fileIdChecksMap = mutableMapOf<FileId, DateTime>()
+        private val checkingDelayTimeSpan = checkingDelay.milliseconds
+
+        override suspend fun TelegramBot.isActual(mediaContent: MediaContent): Boolean {
+            val now = DateTime.now()
+            val lastCheck = fileIdChecksMap[mediaContent.media.fileId]
+            return if (lastCheck == null || now - lastCheck > checkingDelayTimeSpan) {
+                with(underhoodChecker) {
+                    isActual(mediaContent)
+                }.also {
+                    if (it) {
+                        fileIdChecksMap[mediaContent.media.fileId] = now
+                    }
+                }
+            } else {
+                true
+            }
+        }
+
+        override suspend fun TelegramBot.saved(mediaContent: MediaContent) {
+            fileIdChecksMap[mediaContent.media.fileId] = DateTime.now()
+        }
+    }
+}

cache/content/common/src/commonMain/kotlin/dev/inmo/tgbotapi/libraries/cache/media/common/MessageContentCache.kt

@@ -0,0 +1,17 @@
+package dev.inmo.tgbotapi.libraries.cache.media.common
+
+import dev.inmo.tgbotapi.types.message.content.abstracts.MediaContent
+import dev.inmo.tgbotapi.types.message.content.abstracts.MessageContent
+import io.ktor.utils.io.core.Input
+
+interface MessageContentCache<K> {
+    suspend fun save(content: MessageContent): K
+    suspend fun save(
+        content: MediaContent,
+        filename: String,
+        inputAllocator: suspend () -> Input
+    ): K
+    suspend fun get(k: K): MessageContent?
+    suspend fun contains(k: K): Boolean
+    suspend fun remove(k: K)
+}

cache/content/common/src/commonMain/kotlin/dev/inmo/tgbotapi/libraries/cache/media/common/MessagesFilesCache.kt

@@ -0,0 +1,41 @@
+package dev.inmo.tgbotapi.libraries.cache.media.common
+
+import dev.inmo.tgbotapi.types.ChatId
+import dev.inmo.tgbotapi.types.MessageIdentifier
+import dev.inmo.tgbotapi.utils.StorageFile
+import io.ktor.utils.io.core.*
+
+interface MessagesFilesCache<K> {
+    suspend fun set(k: K, filename: String, inputAllocator: suspend () -> Input)
+    suspend fun get(k: K): StorageFile?
+    suspend fun remove(k: K)
+    suspend fun contains(k: K): Boolean
+}
+
+/**
+ * It is not recommended to use in production realization of [MessagesFilesCache] which has been created for fast
+ * start of application creation with usage of [MessageContentCache] with aim to replace this realization by some
+ * disks-oriented one
+ */
+class InMemoryMessagesFilesCache<K> : MessagesFilesCache<K> {
+    private val map = mutableMapOf<K, StorageFile>()
+
+    override suspend fun set(k: K, filename: String, inputAllocator: suspend () -> Input) {
+        map[k] = StorageFile(
+            filename,
+            inputAllocator().readBytes()
+        )
+    }
+
+    override suspend fun get(k: K): StorageFile? {
+        return map[k]
+    }
+
+    override suspend fun remove(k: K) {
+        map.remove(k)
+    }
+
+    override suspend fun contains(k: K): Boolean {
+        return map.contains(k)
+    }
+}

cache/content/common/src/commonMain/kotlin/dev/inmo/tgbotapi/libraries/cache/media/common/MessagesSimpleCache.kt

@@ -0,0 +1,63 @@
+package dev.inmo.tgbotapi.libraries.cache.media.common
+
+import com.benasher44.uuid.uuid4
+import dev.inmo.tgbotapi.types.message.content.abstracts.MessageContent
+
+interface MessagesSimpleCache<K> {
+    suspend fun add(content: MessageContent): K
+    suspend fun update(k: K, content: MessageContent): Boolean
+    suspend fun get(k: K): MessageContent?
+    suspend fun remove(k: K)
+    suspend fun contains(k: K): Boolean
+}
+
+/**
+ * It is not recommended to use in production realization of [MessagesFilesCache] which has been created for fast
+ * start of application creation with usage of [MessageContentCache] with aim to replace this realization by some
+ * disks-oriented one
+ */
+class InMemoryMessagesSimpleCache<K>(
+    private val keyGenerator: () -> K
+) : MessagesSimpleCache<K> {
+    private val map = mutableMapOf<K, MessageContent>()
+
+    override suspend fun add(
+        content: MessageContent
+    ): K {
+        val key = keyGenerator()
+        map[key] = content
+        return key
+    }
+
+    override suspend fun update(
+        k: K,
+        content: MessageContent
+    ): Boolean {
+        return map.runCatching {
+            if (contains(k)) {
+                put(k, content)
+                true
+            } else {
+                false
+            }
+        }.getOrDefault(false)
+    }
+
+    override suspend fun get(k: K): MessageContent? {
+        return map[k]
+    }
+
+    override suspend fun remove(k: K) {
+        map.remove(k)
+    }
+
+    override suspend fun contains(k: K): Boolean {
+        return map.contains(k)
+    }
+
+    companion object {
+        operator fun invoke() = InMemoryMessagesSimpleCache {
+            uuid4().toString()
+        }
+    }
+}

cache/content/common/src/jvmMain/kotlin/dev/inmo/tgbotapi/libraries/cache/media/common/InFilesMessagesFilesCache.kt

@@ -0,0 +1,74 @@
+package dev.inmo.tgbotapi.libraries.cache.media.common
+
+import dev.inmo.tgbotapi.utils.*
+import io.ktor.utils.io.core.Input
+import io.ktor.utils.io.core.copyTo
+import io.ktor.utils.io.streams.asInput
+import io.ktor.utils.io.streams.asOutput
+import java.io.File
+
+class InFilesMessagesFilesCache<K>(
+    private val folderFile: File,
+    private val filePrefixBuilder: (K) -> String
+) : MessagesFilesCache<K> {
+    private val K.storageFile: StorageFile?
+        get() {
+            val prefix = filePrefix(this)
+            val filename = folderFile.list() ?.firstOrNull { it.startsWith(prefix) } ?: return null
+            val file = File(folderFile, filename)
+            val storageFileFilename = file.name.removePrefix("$prefix ")
+
+            return StorageFile(
+                StorageFileInfo(storageFileFilename)
+            ) {
+                file.inputStream().asInput()
+            }
+        }
+
+    init {
+        require(!folderFile.isFile) { "Folder of messages files cache can't be file, but was $folderFile" }
+        folderFile.mkdirs()
+    }
+
+    private fun filePrefix(k: K): String = filePrefixBuilder(k)
+
+    private fun fileName(k: K, filename: String): String {
+        return "${filePrefix(k)} $filename"
+    }
+
+    override suspend fun set(k: K, filename: String, inputAllocator: suspend () -> Input) {
+        val fullFileName = fileName(k, filename)
+        val file = File(folderFile, fullFileName).apply {
+            delete()
+        }
+        inputAllocator().use { input ->
+            file.outputStream().asOutput().use { output ->
+                input.copyTo(output)
+            }
+        }
+    }
+
+    override suspend fun get(k: K): StorageFile? {
+        return k.storageFile
+    }
+
+    override suspend fun remove(k: K) {
+        val prefix = filePrefix(k)
+        folderFile.listFiles() ?.forEach {
+            if (it.name.startsWith(prefix)) {
+                it.delete()
+            }
+        }
+    }
+
+    override suspend fun contains(k: K): Boolean {
+        val prefix = filePrefix(k)
+        return folderFile.list() ?.any { it.startsWith(prefix) } == true
+    }
+
+    companion object {
+        operator fun invoke(folderFile: File) = InFilesMessagesFilesCache<String>(
+            folderFile
+        ) { it }
+    }
+}

cache/content/common/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest package="dev.inmo.tgbotapi.libraries.cache.content.common"/>

cache/content/micro_utils/build.gradle

@@ -10,8 +10,10 @@ kotlin {
     sourceSets {
         commonMain {
             dependencies {
-                api "dev.inmo:micro_utils.coroutines:$micro_utils_version"
+                api "dev.inmo:micro_utils.repos.common:$micro_utils_version"
+                api project(":tgbotapi.libraries.cache.content.common")
             }
         }
     }
 }
+

cache/content/micro_utils/src/commonMain/kotlin/dev/inmo/tgbotapi/libraries/cache/media/micro_utils/SimpleKeyValueMessageContentCache.kt

@@ -0,0 +1,104 @@
+package dev.inmo.tgbotapi.libraries.cache.media.micro_utils
+
+import com.benasher44.uuid.uuid4
+import dev.inmo.micro_utils.repos.*
+import dev.inmo.micro_utils.repos.mappers.withMapper
+import dev.inmo.tgbotapi.libraries.cache.media.common.MessagesSimpleCache
+import dev.inmo.tgbotapi.types.ChatId
+import dev.inmo.tgbotapi.types.MessageIdentifier
+import dev.inmo.tgbotapi.types.message.content.abstracts.MessageContent
+import kotlinx.serialization.*
+import kotlinx.serialization.builtins.PairSerializer
+import kotlinx.serialization.builtins.serializer
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.modules.SerializersModule
+import kotlin.js.JsName
+import kotlin.jvm.JvmName
+
+class SimpleKeyValueMessageContentCache<K>(
+    private val keyValueRepo: KeyValueRepo<K, MessageContent>,
+    private val keyGenerator: () -> K
+) : MessagesSimpleCache<K> {
+    override suspend fun add(content: MessageContent): K {
+        val key = keyGenerator()
+        keyValueRepo.set(key, content)
+
+        return key
+    }
+
+    override suspend fun update(k: K, content: MessageContent): Boolean {
+        return keyValueRepo.runCatching {
+            if (contains(k)) {
+                keyValueRepo.set(k, content)
+                true
+            } else {
+                false
+            }
+        }.getOrDefault(false)
+    }
+
+    override suspend fun get(k: K): MessageContent? {
+        return keyValueRepo.get(k)
+    }
+
+    override suspend fun contains(k: K): Boolean {
+        return keyValueRepo.contains(k)
+    }
+
+    override suspend fun remove(k: K) {
+        keyValueRepo.unset(k)
+    }
+
+    companion object {
+        operator fun invoke(
+            keyValueRepo: KeyValueRepo<String, MessageContent>
+        ) = SimpleKeyValueMessageContentCache(keyValueRepo) { uuid4().toString() }
+    }
+}
+
+val chatIdToMessageIdentifierSerializer = PairSerializer(
+    ChatId.serializer(),
+    MessageIdentifier.serializer()
+)
+
+val messageContentSerializer = PolymorphicSerializer<MessageContent>(MessageContent::class)
+
+inline fun KeyValueRepo<String, String>.asMessageContentCache(
+    serialFormatCreator: (SerializersModule) -> StringFormat = { Json { serializersModule = it } }
+): StandardKeyValueRepo<Pair<ChatId, MessageIdentifier>, MessageContent> {
+    val serialFormat = serialFormatCreator(MessageContent.serializationModule())
+    return withMapper<Pair<ChatId, MessageIdentifier>, MessageContent, String, String>(
+        { serialFormat.encodeToString(chatIdToMessageIdentifierSerializer, this) },
+        { serialFormat.encodeToString(messageContentSerializer, this) },
+        { serialFormat.decodeFromString(chatIdToMessageIdentifierSerializer, this) },
+        { serialFormat.decodeFromString(messageContentSerializer, this) },
+    )
+}
+
+@JvmName("stringsKeyValueAsHexMessageContentCache")
+@JsName("stringsKeyValueAsHexMessageContentCache")
+inline fun KeyValueRepo<String, String>.asMessageContentCache(
+    serialFormatCreator: (SerializersModule) -> BinaryFormat
+): StandardKeyValueRepo<Pair<ChatId, MessageIdentifier>, MessageContent> {
+    val serialFormat = serialFormatCreator(MessageContent.serializationModule())
+    return withMapper<Pair<ChatId, MessageIdentifier>, MessageContent, String, String>(
+        { serialFormat.encodeToHexString(chatIdToMessageIdentifierSerializer, this) },
+        { serialFormat.encodeToHexString(messageContentSerializer, this) },
+        { serialFormat.decodeFromHexString(chatIdToMessageIdentifierSerializer, this) },
+        { serialFormat.decodeFromHexString(messageContentSerializer, this) },
+    )
+}
+
+@JvmName("bytesKeyValueAsMessageContentCache")
+@JsName("bytesKeyValueAsMessageContentCache")
+inline fun KeyValueRepo<ByteArray, ByteArray>.asMessageContentCache(
+    serialFormatCreator: (SerializersModule) -> BinaryFormat
+): StandardKeyValueRepo<Pair<ChatId, MessageIdentifier>, MessageContent> {
+    val serialFormat = serialFormatCreator(MessageContent.serializationModule())
+    return withMapper<Pair<ChatId, MessageIdentifier>, MessageContent, ByteArray, ByteArray>(
+        { serialFormat.encodeToByteArray(chatIdToMessageIdentifierSerializer, this) },
+        { serialFormat.encodeToByteArray(messageContentSerializer, this) },
+        { serialFormat.decodeFromByteArray(chatIdToMessageIdentifierSerializer, this) },
+        { serialFormat.decodeFromByteArray(messageContentSerializer, this) },
+    )
+}

cache/content/micro_utils/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest package="dev.inmo.tgbotapi.libraries.cache.content.micro_utils"/>

cache/media/build.gradle

@@ -1,8 +0,0 @@
-plugins {
-    id "org.jetbrains.kotlin.multiplatform"
-    id "org.jetbrains.kotlin.plugin.serialization"
-    id "com.android.library"
-}
-
-apply from: "$mppProjectWithSerializationPresetPath"
-

cache/media/src/main/AndroidManifest.xml

@@ -1 +0,0 @@
-<manifest package="dev.inmo.tgbotapi.libraries.cache.media"/>

fsm/core/src/commonMain/kotlin/dev/inmo/tgbotapi/libraries/fsm/core/State.kt

@@ -1,17 +0,0 @@
-package dev.inmo.tgbotapi.libraries.fsm.core
-
-sealed interface State {
-    val context: Any
-}
-
-/**
- * Use this state as parent of your state in case you want to avoid saving of this state in queue for [context] if this
- * queue is not empty
- */
-interface ImmediateOrNeverState : State
-
-/**
- * Use this state as parent of your state in case you want to keep saving of this state in queue for [context] if this
- * queue is not empty
- */
-interface QueueableState : State

fsm/core/src/commonMain/kotlin/dev/inmo/tgbotapi/libraries/fsm/core/StateHandlerHolder.kt

@@ -1,15 +0,0 @@
-package dev.inmo.tgbotapi.libraries.fsm.core
-
-import kotlin.reflect.KClass
-
-class StateHandlerHolder<I : State>(
-    private val inputKlass: KClass<I>,
-    private val strict: Boolean = false,
-    private val delegateTo: StatesHandler<I>
-) : StatesHandler<State> {
-    fun checkHandleable(state: State) = state::class == inputKlass || (!strict && inputKlass.isInstance(state))
-
-    override suspend fun StatesMachine.handleState(state: State): State? {
-        return delegateTo.run { handleState(state as I) }
-    }
-}

fsm/core/src/commonMain/kotlin/dev/inmo/tgbotapi/libraries/fsm/core/StatesHandler.kt

@@ -1,5 +0,0 @@
-package dev.inmo.tgbotapi.libraries.fsm.core
-
-fun interface StatesHandler<I : State> {
-    suspend fun StatesMachine.handleState(state: I): State?
-}

fsm/core/src/commonMain/kotlin/dev/inmo/tgbotapi/libraries/fsm/core/StatesMachine.kt

@@ -1,46 +0,0 @@
-package dev.inmo.tgbotapi.libraries.fsm.core
-
-import dev.inmo.micro_utils.coroutines.*
-import kotlinx.coroutines.*
-import kotlinx.coroutines.flow.asFlow
-
-private suspend fun <I : State> StatesMachine.launchStateHandling(
-    state: State,
-    handlers: List<StateHandlerHolder<out I>>
-): State? {
-    return handlers.firstOrNull { it.checkHandleable(state) } ?.run {
-        handleState(state)
-    }
-}
-
-class StatesMachine (
-    private val statesManager: StatesManager,
-    private val handlers: List<StateHandlerHolder<*>>
-) : StatesHandler<State> {
-    override suspend fun StatesMachine.handleState(state: State): State? = launchStateHandling(state, handlers)
-
-    fun start(scope: CoroutineScope): Job = scope.launchSafelyWithoutExceptions {
-        val statePerformer: suspend (State) -> Unit = { state: State ->
-            val newState = launchStateHandling(state, handlers)
-            if (newState != null) {
-                statesManager.update(state, newState)
-            } else {
-                statesManager.endChain(state)
-            }
-        }
-        statesManager.onStartChain.subscribeSafelyWithoutExceptions(this) {
-            launch { statePerformer(it) }
-        }
-        statesManager.onChainStateUpdated.subscribeSafelyWithoutExceptions(this) {
-            launch { statePerformer(it.second) }
-        }
-
-        statesManager.getActiveStates().forEach {
-            launch { statePerformer(it) }
-        }
-    }
-
-    suspend fun startChain(state: State) {
-        statesManager.startChain(state)
-    }
-}

fsm/core/src/commonMain/kotlin/dev/inmo/tgbotapi/libraries/fsm/core/StatesManager.kt

@@ -1,92 +0,0 @@
-package dev.inmo.tgbotapi.libraries.fsm.core
-
-import kotlinx.coroutines.flow.*
-import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.withLock
-
-interface StatesManager {
-    val onChainStateUpdated: Flow<Pair<State, State>>
-    val onStartChain: Flow<State>
-    val onEndChain: Flow<State>
-
-
-    /**
-     * Must set current set using [State.context]
-     */
-    suspend fun update(old: State, new: State)
-
-    /**
-     * Starts chain with [state] as first [State]. May returns false in case of [State.context] of [state] is already
-     * busy by the other [State]
-     */
-    suspend fun startChain(state: State)
-
-    /**
-     * Ends chain with context from [state]. In case when [State.context] of [state] is absent, [state] should be just
-     * ignored
-     */
-    suspend fun endChain(state: State)
-
-    suspend fun getActiveStates(): List<State>
-}
-
-/**
- * @param onContextsConflictResolver Receive old [State], new one and the state currently placed on new [State.context]
- * key. In case when this callback will returns true, the state placed on [State.context] of new will be replaced by
- * new state by using [endChain] with that state
- */
-class InMemoryStatesManager(
-    private val onContextsConflictResolver: suspend (old: State, new: State, currentNew: State) -> Boolean = { _, _, _ -> true }
-) : StatesManager {
-    private val _onChainStateUpdated = MutableSharedFlow<Pair<State, State>>(0)
-    override val onChainStateUpdated: Flow<Pair<State, State>> = _onChainStateUpdated.asSharedFlow()
-    private val _onStartChain = MutableSharedFlow<State>(0)
-    override val onStartChain: Flow<State> = _onStartChain.asSharedFlow()
-    private val _onEndChain = MutableSharedFlow<State>(0)
-    override val onEndChain: Flow<State> = _onEndChain.asSharedFlow()
-
-    private val contextsToStates = mutableMapOf<Any, State>()
-    private val mapMutex = Mutex()
-
-    override suspend fun update(old: State, new: State) = mapMutex.withLock {
-        when {
-            contextsToStates[old.context] != old -> return@withLock
-            old.context == new.context || !contextsToStates.containsKey(new.context) -> {
-                contextsToStates[old.context] = new
-                _onChainStateUpdated.emit(old to new)
-            }
-            else -> {
-                val stateOnNewOneContext = contextsToStates.getValue(new.context)
-                if (onContextsConflictResolver(old, new, stateOnNewOneContext)) {
-                    endChainWithoutLock(stateOnNewOneContext)
-                    contextsToStates.remove(old.context)
-                    contextsToStates[new.context] = new
-                    _onChainStateUpdated.emit(old to new)
-                }
-            }
-        }
-    }
-
-    override suspend fun startChain(state: State) = mapMutex.withLock {
-        if (!contextsToStates.containsKey(state.context)) {
-            contextsToStates[state.context] = state
-            _onStartChain.emit(state)
-        }
-    }
-
-    private suspend fun endChainWithoutLock(state: State) {
-        if (contextsToStates[state.context] == state) {
-            contextsToStates.remove(state.context)
-            _onEndChain.emit(state)
-        }
-    }
-
-    override suspend fun endChain(state: State) {
-        mapMutex.withLock {
-            endChainWithoutLock(state)
-        }
-    }
-
-    override suspend fun getActiveStates(): List<State> = contextsToStates.values.toList()
-
-}

fsm/core/src/commonMain/kotlin/dev/inmo/tgbotapi/libraries/fsm/core/dsl/FSMBuilder.kt

@@ -1,35 +0,0 @@
-package dev.inmo.tgbotapi.libraries.fsm.core.dsl
-
-import dev.inmo.tgbotapi.libraries.fsm.core.*
-import kotlin.reflect.KClass
-
-class FSMBuilder(
-    var statesManager: StatesManager = InMemoryStatesManager()
-) {
-    private var states = mutableListOf<StateHandlerHolder<*>>()
-
-    fun <I : State> add(kClass: KClass<I>, handler: StatesHandler<I>) {
-        states.add(StateHandlerHolder(kClass, false, handler))
-    }
-
-    fun <I : State> addStrict(kClass: KClass<I>, handler: StatesHandler<I>) {
-        states.add(StateHandlerHolder(kClass, true, handler))
-    }
-
-    fun build() = StatesMachine(
-        statesManager,
-        states.toList()
-    )
-}
-
-inline fun <reified I : State> FSMBuilder.onStateOrSubstate(handler: StatesHandler<I>) {
-    add(I::class, handler)
-}
-
-inline fun <reified I : State> FSMBuilder.strictlyOn(handler: StatesHandler<I>) {
-    addStrict(I::class, handler)
-}
-
-fun buildFSM(
-    block: FSMBuilder.() -> Unit
-): StatesMachine = FSMBuilder().apply(block).build()

fsm/core/src/jvmTest/kotlin/PlayableMain.kt

@@ -1,54 +0,0 @@
-import dev.inmo.tgbotapi.libraries.fsm.core.*
-import dev.inmo.tgbotapi.libraries.fsm.core.dsl.buildFSM
-import dev.inmo.tgbotapi.libraries.fsm.core.dsl.strictlyOn
-import kotlinx.coroutines.*
-import kotlin.random.Random
-import kotlin.test.Test
-
-sealed interface TrafficLightState : ImmediateOrNeverState {
-    val trafficLightNumber: Int
-    override val context: Int
-        get() = trafficLightNumber
-}
-data class GreenCommon(override val trafficLightNumber: Int) : TrafficLightState
-data class YellowCommon(override val trafficLightNumber: Int) : TrafficLightState
-data class RedCommon(override val trafficLightNumber: Int) : TrafficLightState
-
-class PlayableMain {
-    fun test() {
-        runBlocking {
-            val countOfTrafficLights = 10
-            val initialStates = (0 until countOfTrafficLights).map {
-                when (0/*Random.nextInt(3)*/) {
-                    0 -> GreenCommon(it)
-                    1 -> YellowCommon(it)
-                    else -> RedCommon(it)
-                }
-            }
-
-            val statesManager = InMemoryStatesManager()
-
-            val machine = buildFSM {
-                strictlyOn<GreenCommon> {
-                    delay(1000L)
-                    YellowCommon(it.context).also(::println)
-                }
-                strictlyOn<YellowCommon> {
-                    delay(1000L)
-                    RedCommon(it.context).also(::println)
-                }
-                strictlyOn<RedCommon> {
-                    delay(1000L)
-                    GreenCommon(it.context).also(::println)
-                }
-                this.statesManager = statesManager
-            }
-
-            initialStates.forEach { machine.startChain(it) }
-
-            val scope = CoroutineScope(Dispatchers.Default)
-            machine.start(scope).join()
-
-        }
-    }
-}

fsm/core/src/main/AndroidManifest.xml

@@ -1 +0,0 @@
-<manifest package="dev.inmo.tgbotapi.libraries.fsm.core"/>

fsm/tgbotapi/src/main/AndroidManifest.xml

@@ -1 +0,0 @@
-<manifest package="dev.inmo.tgbotapi.libraries.fsm.tgbotapi"/>

gradle.properties

@@ -6,33 +6,32 @@ kotlin.incremental.js=true
 android.useAndroidX=true
 android.enableJetifier=true
 
-kotlin_version=1.5.10
-kotlin_serialisation_core_version=1.2.1
-kotlin_coroutines_version=1.5.0
+kotlin_version=1.6.21
+kotlin_serialisation_core_version=1.3.3
 
-github_release_plugin_version=2.2.12
+github_release_plugin_version=2.3.7
 
-tgbotapi_version=0.35.0
-micro_utils_version=0.5.12
-exposed_version=0.32.1
-plagubot_version=0.3.0
+tgbotapi_version=1.1.0
+micro_utils_version=0.10.4
+exposed_version=0.38.2
+plagubot_version=1.0.0
 
 # ANDROID
 
 android_minSdkVersion=21
-android_compileSdkVersion=30
-android_buildToolsVersion=30.0.3
-dexcount_version=2.0.0
+android_compileSdkVersion=32
+android_buildToolsVersion=32.0.0
+dexcount_version=3.1.0
 junit_version=4.12
 test_ext_junit_version=1.1.2
 espresso_core=3.3.0
 
 # Dokka
 
-dokka_version=1.4.32
+dokka_version=1.6.21
 
 # Project data
 
 group=dev.inmo
-version=0.0.10
-android_code_version=9
+version=0.0.19
+android_code_version=19

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.8.2-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.4.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

mppJavaProject.gradle

@@ -28,3 +28,8 @@ kotlin {
         }
     }
 }
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}

mppProjectWithSerialization.gradle

@@ -47,4 +47,9 @@ kotlin {
     }
 }
 
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}
+
 apply from: "$defaultAndroidSettingsPresetPath"

publish.gradle

@@ -38,6 +38,7 @@ publishing {
             }
         }
         repositories {
+            if ((project.hasProperty('GITHUBPACKAGES_USER') || System.getenv('GITHUBPACKAGES_USER') != null) && (project.hasProperty('GITHUBPACKAGES_PASSWORD') || System.getenv('GITHUBPACKAGES_PASSWORD') != null)) {
                 maven {
                     name = "GithubPackages"
                     url = uri("https://maven.pkg.github.com/InsanusMokrassar/TelegramBotApiLibraries")
@@ -47,5 +48,32 @@ publishing {
                     }
                 }
             }
+            if ((project.hasProperty('SONATYPE_USER') || System.getenv('SONATYPE_USER') != null) && (project.hasProperty('SONATYPE_PASSWORD') || System.getenv('SONATYPE_PASSWORD') != null)) {
+                maven {
+                    name = "sonatype"
+                    url = uri("https://oss.sonatype.org/service/local/staging/deploy/maven2/")
+                    credentials {
+                        username = project.hasProperty('SONATYPE_USER') ? project.property('SONATYPE_USER') : System.getenv('SONATYPE_USER')
+                        password = project.hasProperty('SONATYPE_PASSWORD') ? project.property('SONATYPE_PASSWORD') : System.getenv('SONATYPE_PASSWORD')
+                    }
+                }
+            }
+        }
+    }
+}
+    
+if (project.hasProperty("signing.gnupg.keyName")) {
+    apply plugin: 'signing'
+    
+    signing {
+        useGpgCmd()
+    
+        sign publishing.publications
+    }
+    
+    task signAll {
+        tasks.withType(Sign).forEach {
+            dependsOn(it)
+        }
     }
 }

publish.kpsb

@@ -0,0 +1 @@
+{"licenses":[{"id":"MIT","title":"MIT License","url":"https://opensource.org/licenses/MIT"}],"mavenConfig":{"name":"${project.name}","description":"${project.name}","url":"https://github.com/InsanusMokrassar/TelegramBotApiLibraries","vcsUrl":"https://github.com/InsanusMokrassar/TelegramBotApiLibraries.git","developers":[{"id":"InsanusMokrassar","name":"Ovsiannikov Aleksei","eMail":"ovsyannikov.alexey95@gmail.com"}],"repositories":[{"name":"GithubPackages","url":"https://maven.pkg.github.com/InsanusMokrassar/TelegramBotApiLibraries"},{"name":"sonatype","url":"https://oss.sonatype.org/service/local/staging/deploy/maven2/"}],"gpgSigning":{"type":"dev.inmo.kmppscriptbuilder.core.models.GpgSigning.Optional"}}}

publish_config.kpsb

@@ -1 +0,0 @@
-{"licenses":[{"id":"MIT","title":"MIT License","url":"https://opensource.org/licenses/MIT"}],"mavenConfig":{"name":"${project.name}","description":"${project.name}","url":"https://github.com/InsanusMokrassar/TelegramBotApiLibraries","vcsUrl":"https://github.com/InsanusMokrassar/TelegramBotApiLibraries.git","includeGpgSigning":false,"developers":[{"id":"InsanusMokrassar","name":"Ovsiannikov Aleksei","eMail":"ovsyannikov.alexey95@gmail.com"}],"repositories":[{"name":"GithubPackages","url":"https://maven.pkg.github.com/InsanusMokrassar/TelegramBotApiLibraries"}]}}

settings.gradle

@@ -4,16 +4,15 @@ String[] includes = [
     ":cache:admins:common",
     ":cache:admins:micro_utils",
     ":cache:admins:plagubot",
-    ":cache:media",
 
-    ":fsm:core",
-    ":fsm:tgbotapi"
+    ":cache:content:common",
+    ":cache:content:micro_utils",
 ]
 
 
 includes.each { originalName ->
-    String projectDirectory = "${rootProject.projectDir.getAbsolutePath()}${originalName.replaceAll(":", File.separator)}"
-    String projectName = "${rootProject.name}${originalName.replaceAll(":", ".")}"
+    String projectDirectory = "${rootProject.projectDir.getAbsolutePath()}${originalName.replace(":", File.separator)}"
+    String projectName = "${rootProject.name}${originalName.replace(":", ".")}"
     String projectIdentifier = ":${projectName}"
     include projectIdentifier
     ProjectDescriptor project = project(projectIdentifier)