Skip to content

Kotlin Multiplatformでフルスタックアプリケーションを構築する

コード例: full-stack-task-manager

使用プラグイン: Routingルーティングは、サーバーアプリケーションにおいて着信リクエストを処理するためのコアとなるプラグインです。、 kotlinx.serialization、 Content NegotiationContentNegotiation プラグインには、主に2つの目的があります。クライアントとサーバー間でのメディアタイプのネゴシエーション、および特定の形式でのコンテンツのシリアライズ/デシリアライズです。、 Compose Multiplatform、 Kotlin Multiplatform

この記事では、Android、iOS、Web、Desktopプラットフォームで動作し、Ktorを活用してシームレスなデータ処理を行うフルスタックアプリケーションをKotlinで開発する方法を学びます。

このチュートリアルを終えると、以下のことができるようになります。

  • Kotlin Multiplatformを使用したフルスタックアプリケーションの作成。
  • IntelliJ IDEAで生成されたプロジェクトの理解。
  • Ktorサービスを呼び出すCompose Multiplatformクライアントの作成。
  • 設計の異なるレイヤー間での共有型の再利用。
  • マルチプラットフォームライブラリの正しい追加と設定。

以前のチュートリアルでは、タスクマネージャーの例を使用して、 リクエストの処理タスクマネージャーアプリケーションを構築しながら、KotlinとKtorによるルーティング、リクエスト処理、およびパラメーターの基本を学びます。、 RESTful APIの作成Kotlin と Ktor を使用してバックエンドサービスを構築する方法を、JSON ファイルを生成する RESTful API の例を通して学びます。、および Exposedを使用したデータベースの統合Exposed SQL ライブラリを使用して Ktor サービスをデータベースリポジトリに接続するプロセスを学びます。を行いました。 Ktorの基礎を学ぶことに集中できるよう、クライアントアプリケーションは最小限に抑えられていました。

ここでは、Android、iOS、Web、Desktopプラットフォームをターゲットとし、表示するデータをKtorサービスから取得するクライアントを作成します。可能な限りクライアントとサーバー間でデータ型を共有し、開発をスピードアップしてエラーの発生リスクを減らします。

前提条件

これまでの記事と同様に、IDEとしてIntelliJ IDEAを使用します。環境のインストールと設定については、 Kotlin Multiplatform クイックスタート を参照してください。

Compose Multiplatformを使用するのが初めての場合は、このチュートリアルを開始する前に Get started with Compose Multiplatform チュートリアルを完了することをお勧めします。作業の複雑さを減らすために、単一のクライアントプラットフォームに絞って進めることもできます。たとえば、iOSを使用したことがない場合は、デスクトップまたはAndroid開発に集中するのが賢明かもしれません。

新規プロジェクトの作成

Ktorプロジェクトジェネレーターの代わりに、IntelliJ IDEAのKotlin Multiplatformプロジェクトウィザードを使用します。 これにより、クライアントとサービスで拡張できる基本的なマルチプラットフォームプロジェクトが作成されます。クライアントはSwiftUIなどのネイティブUIライブラリを使用することもできますが、このチュートリアルではCompose Multiplatformを使用してすべてのプラットフォーム共通のUIを作成します。

  1. IntelliJ IDEAを起動します。
  2. IntelliJ IDEAで、 File | New | Project を選択します。
  3. 左側のパネルで Kotlin Multiplatform を選択します。
  4. New Project ウィンドウで以下のフィールドを指定します。
    • Name : full-stack-task-manager
    • Project ID : com.example.ktor
  5. ターゲットプラットフォームとして Android 、 Desktop 、 Web 、および Server を選択します。

  6. Macを使用している場合は、 iOS も選択します。その際、 Share UI オプションが選択されていることを確認してください。 Kotlin Multiplatformウィザードの設定

  7. Create ボタンをクリックし、IDEがプロジェクトを生成およびインポートするのを待ちます。

サービスの実行

  1. IntelliJ IDEAで、 ApplicationKt 実行構成を選択します。 Run & Debugウィンドウ
  2. Run ボタン (IntelliJ IDEAの実行アイコン) をクリックして構成を実行します。

    Run ツールウィンドウに新しいタブが開きます。

  3. http://0.0.0.0:8080/ にアクセスしてアプリケーションを開きます。 ブラウザにKtorからのメッセージが表示されるはずです。 ブラウザに表示されたKtorサーバーのレスポンス

プロジェクトの構造を確認する

server フォルダは、プロジェクト内にある3つのKotlinモジュールのうちの1つです。他の2つは core と app です。

server モジュールの構造は、Ktor Project Generatorで生成されるものと非常によく似ています。 プラグインと依存関係を宣言するための専用ビルドファイルがあり、Ktorサービスをビルドして起動するためのコードを含むソースセットが存在します。

Kotlin Multiplatformプロジェクト内のserverフォルダの内容

Application.kt ファイル内のルーティングの指示を見ると、sayHello() 関数の呼び出しがあります。

kotlin
fun Application.module() {
    routing {
        get("/") {
            call.respondText(sayHello("Ktor"))
        }
    }
}

sayHello() 関数は core モジュールで定義されています。ここは、サーバーとすべての異なるクライアントプラットフォーム間で共有される共通コードを配置する場所です。

app/shared/src/commonMain モジュール内の Greeting.kt ファイルを開くと、そこでも sayHello() 関数が使用されていることがわかります。

kotlin
class Greeting {
    private val platform = getPlatform()

    fun greet(): String {
        return sayHello(platform.name)
    }
}

app モジュールには、以下のサブモジュールが含まれています。

  • androidApp、desktopApp、iosApp、および webApp サブモジュールには、それぞれAndroid、Desktop、iOS、Webクライアントアプリ向けのプラットフォーム固有のコードが含まれています。現時点では、これらのクライアントアプリはいずれもKtorサービスに接続されていません。
  • shared サブモジュールには、クライアントを提供したいプラットフォームごとのソースセットが含まれています。これは、 commonMain 内で宣言された型が、ターゲットプラットフォームによって異なる機能を必要とするためです。

    たとえば、Greeting 型では、現在のプラットフォームの名前が、期待される宣言と実際の宣言 (expected and actual declarations) を通じてプラットフォーム固有のAPIを使用して取得されます。

    shared サブモジュールの commonMain ソースセットでは、getPlatform() 関数が expect キーワードとともに宣言されています。

    kotlin
    package com.example.ktor
    
    interface Platform {
        val name: String
    }
    
    expect fun getPlatform(): Platform

    その後、以下に示すように、各ターゲットプラットフォームが getPlatform() 関数の actual 宣言を提供します。

    kotlin
    package com.example.ktor
    
    import platform.UIKit.UIDevice
    
    class IOSPlatform : Platform {
        override val name: String = UIDevice.currentDevice.systemName() + " " + UIDevice.currentDevice.systemVersion
    }
    
    actual fun getPlatform(): Platform = IOSPlatform()
    kotlin
    package com.example.ktor
    
    import android.os.Build
    
    class AndroidPlatform : Platform {
        override val name: String = "Android ${Build.VERSION.SDK_INT}"
    }
    
    actual fun getPlatform(): Platform = AndroidPlatform()
    kotlin
    package com.example.ktor
    
    class JVMPlatform : Platform {
        override val name: String = "Java ${System.getProperty("java.version")}"
    }
    
    actual fun getPlatform(): Platform = JVMPlatform()
    kotlin
    package com.example.ktor
    
    class WasmPlatform : Platform {
        override val name: String = "Web with Kotlin/Wasm"
    }
    
    actual fun getPlatform(): Platform = WasmPlatform()

クライアントアプリケーションの実行

ターゲットの実行構成を実行することで、クライアントアプリケーションを起動できます。iOSシミュレータでアプリケーションを実行するには、以下の手順に従ってください。

  1. IntelliJ IDEAで、 iosApp 実行構成とシミュレートするデバイスを選択します。 Run & Debugウィンドウ
  2. Run ボタン (IntelliJ IDEAの実行アイコン) をクリックして構成を実行します。
  3. iOSアプリを実行すると、内部的にXcodeでビルドされ、iOSシミュレータで起動されます。 アプリには、クリックすると画像の表示/非表示を切り替えるボタンが表示されます。 iOSシミュレータでのアプリの実行

    ボタンを初めて押したときに、現在のプラットフォームの詳細がそのテキストに追加されます。これを実現するコードは app/shared/src/commonMain/kotlin/com/example/ktor/App.kt にあります。

    kotlin
    @Composable
    @Preview
    fun App() {
        MaterialTheme {
            var showContent by remember { mutableStateOf(false) }
            Column(
                modifier = Modifier
                    .background(MaterialTheme.colorScheme.primaryContainer)
                    .safeContentPadding()
                    .fillMaxSize(),
                horizontalAlignment = Alignment.CenterHorizontally,
            ) {
                Button(onClick = { showContent = !showContent }) {
                    Text("Click me!")
                }
                AnimatedVisibility(showContent) {
                    val greeting = remember { Greeting().greet() }
                    Column(
                        modifier = Modifier.fillMaxWidth(),
                        horizontalAlignment = Alignment.CenterHorizontally,
                    ) {
                        Image(painterResource(Res.drawable.compose_multiplatform), null)
                        Text("Compose: $greeting")
                    }
                }
            }
        }
    }

    これはコンポーザブル関数であり、この記事の後半で変更します。現時点で重要なのは、UIを表示し、共通の Platform インターフェースを実装するプラットフォーム固有のクラスを使用する共有の Greeting 型を利用しているということだけです。

生成されたプロジェクトの構造を理解できたので、タスクマネージャーの機能を段階的に追加していきましょう。

モデル型の追加

まず、モデル型を追加し、クライアントとサーバーの双方がアクセスできるようにします。

  1. gradle/libs.versions.toml を開き、以下の kotlinx.serialization 依存関係を定義します。
    toml
    [versions]
    kotlinx-serialization-json = "1.11.0"
    
    [libraries]
    kotlinx-serialization-json = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json", version.ref = "kotlinx-serialization-json" }
    
    [plugins]
    kotlinSerialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
  2. core/build.gradle.kts を開き、シリアライゼーションプラグインを追加します。

    kotlin
    plugins {
        //...
        alias(libs.plugins.kotlinSerialization)
    }
  3. 同じファイルで、 commonMain ソースセットに新しい依存関係を追加します。

    kotlin
    sourceSets {
        commonMain.dependencies {
            // マルチプラットフォームの依存関係をここに配置します
            implementation(libs.kotlinx.serialization.json)
        }
        //...
    }
  4. IntelliJ IDEAで、 Build | Sync Project with Gradle Files を選択して更新を適用します。Gradleのインポートが完了すると、 Task.kt ファイルが正常にコンパイルできるようになります。
  5. core/src/commonMain/kotlin/com/example/ktor へ移動し、 model という新しいパッケージを作成します。
  6. 新しいパッケージ内に、 Task.kt という新しいファイルを作成します。
  7. 優先度を表す enum と、タスクを表すクラスを追加します。 Task クラスには、kotlinx.serialization ライブラリの Serializable 型が注釈されています。

    kotlin
    package com.example.ktor.model
    
    import kotlinx.serialization.Serializable
    
    enum class Priority {
        Low, Medium, High, Vital
    }
    
    @Serializable
    data class Task(
        val name: String,
        val description: String,
        val priority: Priority
    )

サーバーの作成

次の段階は、タスクマネージャーのサーバー実装を作成することです。

  1. server/src/main/kotlin/com/example/ktor フォルダに移動し、 model というサブパッケージを作成します。
  2. このパッケージ内に新しい TaskRepository.kt ファイルを作成し、リポジトリ用の以下のインターフェースを追加します。

    kotlin
    package com.example.ktor.model
    
    interface TaskRepository {
        fun allTasks(): List<Task>
        fun tasksByPriority(priority: Priority): List<Task>
        fun taskByName(name: String): Task?
        fun addOrUpdateTask(task: Task)
        fun removeTask(name: String): Boolean
    }
  3. 同じパッケージ内に、次のクラスを含む InMemoryTaskRepository.kt という新しいファイルを作成します。

    kotlin
    package com.example.ktor.model
    
    class InMemoryTaskRepository : TaskRepository {
        private var tasks = listOf(
            Task("Cleaning", "Clean the house", Priority.Low),
            Task("Gardening", "Mow the lawn", Priority.Medium),
            Task("Shopping", "Buy the groceries", Priority.High),
            Task("Painting", "Paint the fence", Priority.Low),
            Task("Cooking", "Cook the dinner", Priority.Medium),
            Task("Relaxing", "Take a walk", Priority.High),
            Task("Exercising", "Go to the gym", Priority.Low),
            Task("Learning", "Read a book", Priority.Medium),
            Task("Snoozing", "Go for a nap", Priority.High),
            Task("Socializing", "Go to a party", Priority.High)
        )
    
        override fun allTasks(): List<Task> = tasks
    
        override fun tasksByPriority(priority: Priority) = tasks.filter {
            it.priority == priority
        }
    
        override fun taskByName(name: String) = tasks.find {
            it.name.equals(name, ignoreCase = true)
        }
    
        override fun addOrUpdateTask(task: Task) {
            var notFound = true
    
            tasks = tasks.map {
                if (it.name == task.name) {
                    notFound = false
                    task
                } else {
                    it
                }
            }
            if (notFound) {
                tasks = tasks.plus(task)
            }
        }
    
        override fun removeTask(name: String): Boolean {
            val oldTasks = tasks
            tasks = tasks.filterNot { it.name == name }
            return oldTasks.size > tasks.size
        }
    }
  4. server/src/main/kotlin/.../Application.kt を開き、既存のコードを以下の実装に置き換えます。

    kotlin
    package com.example.ktor
    
    import com.example.ktor.model.InMemoryTaskRepository
    import com.example.ktor.model.Priority
    import com.example.ktor.model.Task
    import io.ktor.http.*
    import io.ktor.serialization.*
    import io.ktor.serialization.kotlinx.json.*
    import io.ktor.server.application.*
    import io.ktor.server.engine.*
    import io.ktor.server.netty.*
    import io.ktor.server.plugins.contentnegotiation.*
    import io.ktor.server.plugins.cors.routing.*
    import io.ktor.server.request.*
    import io.ktor.server.response.*
    import io.ktor.server.routing.*
    
    fun main() {
        embeddedServer(Netty, port = 8080, host = "0.0.0.0", module = Application::module)
            .start(wait = true)
    }
    
    fun Application.module() {
        install(ContentNegotiation) {
            json()
        }
        install(CORS) {
            allowHeader(HttpHeaders.ContentType)
            allowMethod(HttpMethod.Delete)
            // デモを簡単にするため、すべての接続を許可しています。
            // 本番環境ではこれを行わないでください。
            anyHost()
        }
        val repository = InMemoryTaskRepository()
    
        routing {
            route("/tasks") {
                get {
                    val tasks = repository.allTasks()
                    call.respond(tasks)
                }
                get("/byName/{taskName}") {
                    val name = call.parameters["taskName"]
                    if (name == null) {
                        call.respond(HttpStatusCode.BadRequest)
                        return@get
                    }
                    val task = repository.taskByName(name)
                    if (task == null) {
                        call.respond(HttpStatusCode.NotFound)
                        return@get
                    }
                    call.respond(task)
                }
                get("/byPriority/{priority}") {
                    val priorityAsText = call.parameters["priority"]
                    if (priorityAsText == null) {
                        call.respond(HttpStatusCode.BadRequest)
                        return@get
                    }
                    try {
                        val priority = Priority.valueOf(priorityAsText)
                        val tasks = repository.tasksByPriority(priority)
    
    
                        if (tasks.isEmpty()) {
                            call.respond(HttpStatusCode.NotFound)
                            return@get
                        }
                        call.respond(tasks)
                    } catch (ex: IllegalArgumentException) {
                        call.respond(HttpStatusCode.BadRequest)
                    }
                }
                post {
                    try {
                        val task = call.receive<Task>()
                        repository.addOrUpdateTask(task)
                        call.respond(HttpStatusCode.NoContent)
                    } catch (ex: IllegalStateException) {
                        call.respond(HttpStatusCode.BadRequest)
                    } catch (ex: JsonConvertException) {
                        call.respond(HttpStatusCode.BadRequest)
                    }
                }
                delete("/{taskName}") {
                    val name = call.parameters["taskName"]
                    if (name == null) {
                        call.respond(HttpStatusCode.BadRequest)
                        return@delete
                    }
                    if (repository.removeTask(name)) {
                        call.respond(HttpStatusCode.NoContent)
                    } else {
                        call.respond(HttpStatusCode.NotFound)
                    }
                }
            }
        }
    }

    この実装は以前のチュートリアルのものと非常によく似ていますが、簡潔にするためにすべてのルーティングコードを Application.module() 関数内に配置している点が異なります。

    このコードを入力してインポートを追加すると、依存関係として含める必要がある複数のKtorプラグイン(Webクライアントとの対話用の CORS必要な依存関係: io.ktor:ktor-server-cors プラグインを含む)を使用しているため、複数のコンパイルエラーが発生します。

  5. settings.gradle.kts を開き、Ktorバージョンカタログをインポートします。
    kotlin
    dependencyResolutionManagement {
        versionCatalogs {
            create("ktorLibs").from("io.ktor:ktor-version-catalog:3.6.1")
        }
    }
  6. サーバーモジュールのビルドファイル( server/build.gradle.kts )を開き、以下の依存関係を追加します。

    kotlin
    dependencies {
        //...
        implementation(ktorLibs.serialization.kotlinx.json)
        implementation(ktorLibs.server.contentNegotiation)
        implementation(ktorLibs.server.cors)
    }
  7. 再度、メインメニューから Build | Sync Project with Gradle Files を選択します。 インポートが完了すると、ContentNegotiation 型および json() 関数のインポートが正しく機能するようになります。
  8. サーバーを再実行します。ブラウザからルートにアクセスできるようになっているはずです。
  9. および にアクセスして、JSON形式のタスクを含むサーバーのレスポンスを確認します。 ブラウザでのサーバーレスポンス

クライアントの作成

クライアントがサーバーにアクセスできるようにするには、Ktor Clientを含める必要があります。これには3種類の依存関係が関係します。

  • Ktor Clientのコア機能。
  • ネットワーク処理を行うプラットフォーム固有のエンジン。
  • コンテンツネゴシエーションとシリアライゼーションのサポート。
  1. app/shared/build.gradle.kts を開き、以下の依存関係を追加します。
    kotlin
    kotlin {
        //...
        sourceSets {
            androidMain.dependencies {
                //...
                implementation(ktorLibs.client.android)
            }
            commonMain.dependencies {
                //...
                implementation(ktorLibs.client.core)
                implementation(ktorLibs.client.contentNegotiation)
                implementation(ktorLibs.serialization.kotlinx.json)
            }
            jvmMain.dependencies {
                implementation(ktorLibs.client.cio)
            }
            iosMain.dependencies {
                implementation(ktorLibs.client.darwin)
            }
            wasmJsMain.dependencies {
                implementation(ktorLibs.client.js)
            }
        }
    }

    これが完了したら、Ktor Clientの薄いラッパーとして機能する TaskApi 型をクライアントに追加できます。

  2. メインメニューで Build | Sync Project with Gradle Files を選択して、 ビルドファイルの変更をインポートします。
  3. app/shared/src/commonMain/kotlin/com/example/ktor へ移動し、 network という新しいパッケージを作成します。
  4. 新しいパッケージ内に、クライアント設定用の新しい HttpClientManager.kt ファイルを作成します。

    kotlin
    package com.example.ktor.network
    
    import io.ktor.client.HttpClient
    import io.ktor.client.plugins.contentnegotiation.ContentNegotiation
    import io.ktor.client.plugins.defaultRequest
    import io.ktor.serialization.kotlinx.json.json
    import kotlinx.serialization.json.Json
    
    fun createHttpClient() = HttpClient {
        install(ContentNegotiation) {
            json(Json {
                encodeDefaults = true
                isLenient = true
                coerceInputValues = true
                ignoreUnknownKeys = true
            })
        }
        defaultRequest {
            host = "1.2.3.4" // 現在のマシンのIPアドレスに置き換えてください。
            port = 8080
        }
    }

    1.2.3.4 を現在のマシンのIPアドレスに置き換えてください。Android Virtual DeviceまたはiOSシミュレータ上で実行されているコードから 0.0.0.0 や localhost への呼び出しを行うことはできません。

    IPアドレスの確認方法:

    モバイルシミュレータは localhost にアクセスできないため、マシンの実際のIPアドレスが必要です。 IPアドレスを確認するには、次のいずれかのコマンドを実行します。

    • macOS: ifconfig | grep "inet " | grep -v 127.0.0.1
    • Linux: hostname -I | awk '{print $1}'
    • Windows: ipconfig を実行し、「IPv4 アドレス」を探します
  5. 同じ app/shared/.../network パッケージ内に、以下の実装を持つ新しい TaskApi.kt ファイルを作成します。

    kotlin
    package com.example.ktor.network
    
    import com.example.ktor.model.Task
    import io.ktor.client.HttpClient
    import io.ktor.client.call.body
    import io.ktor.client.request.delete
    import io.ktor.client.request.get
    import io.ktor.client.request.post
    import io.ktor.client.request.setBody
    import io.ktor.http.ContentType
    import io.ktor.http.contentType
    
    class TaskApi(private val httpClient: HttpClient) {
    
        suspend fun getAllTasks(): List<Task> {
            return httpClient.get("tasks").body()
        }
    
        suspend fun removeTask(task: Task) {
            httpClient.delete("tasks/${task.name}")
        }
    
        suspend fun updateTask(task: Task) {
            httpClient.post("tasks") {
                contentType(ContentType.Application.Json)
                setBody(task)
            }
        }
    }
  6. app/shared/.../App.kt を開き、コードを以下の実装に置き換えます。 これにより、TaskApi 型を使用してサーバーからタスクのリストを取得し、各タスクの名前をカラム内に表示します。

    kotlin
    package com.example.ktor
    
    import com.example.ktor.network.TaskApi
    import com.example.ktor.network.createHttpClient
    import com.example.ktor.model.Task
    import androidx.compose.foundation.layout.Column
    import androidx.compose.foundation.layout.fillMaxSize
    import androidx.compose.foundation.layout.safeContentPadding
    import androidx.compose.material3.Button
    import androidx.compose.material3.MaterialTheme
    import androidx.compose.material3.Text
    import androidx.compose.runtime.*
    import androidx.compose.ui.Alignment
    import androidx.compose.ui.Modifier
    import kotlinx.coroutines.launch
    
    @Composable
    fun App() {
        MaterialTheme {
            val httpClient = createHttpClient()
            val taskApi = remember { TaskApi(httpClient) }
            val tasks = remember { mutableStateOf(emptyList<Task>()) }
            val scope = rememberCoroutineScope()
    
            Column(
                modifier = Modifier
                    .safeContentPadding()
                    .fillMaxSize(),
                horizontalAlignment = Alignment.CenterHorizontally,
            ) {
                Button(onClick = {
                    scope.launch {
                        tasks.value = taskApi.getAllTasks()
                    }
                }) {
                    Text("Fetch Tasks")
                }
                for (task in tasks.value) {
                    Text(task.name)
                }
            }
        }
    }
  7. サーバーが実行されている状態で、iosApp 実行構成を実行してiOSアプリケーションをテストします。

  8. Fetch Tasks ボタンをクリックして、タスクのリストを表示します。 iOSで実行中のアプリ

    このデモでは、わかりやすさのためにプロセスを簡略化しています。実際のアプリケーションでは、暗号化されていないデータをネットワーク経由で送信しないようにすることが極めて重要です。
  9. Androidプラットフォームでは、アプリケーションに明示的にネットワーク権限を付与し、平文でのデータの送受信を許可する必要があります。これらの権限を有効にするには、 app/androidApp/src/main/AndroidManifest.xml を開き、次の設定を追加します。

    xml
    <manifest>
        ...
        <application
                android:usesCleartextTraffic="true">
        ...
        ...
        </application>
        <uses-permission android:name="android.permission.INTERNET"/>
    </manifest>
  10. app.androidApp 実行構成を使用してAndroidアプリケーションを実行します。 これでAndroidクライアントも実行できるようになります。 Androidで実行中のアプリ

  11. デスクトップクライアントの場合は、コンテナとなるウィンドウにサイズとタイトルを割り当てます。 app/desktopApp/src/.../main.kt ファイルを開き、title の変更および state プロパティの設定を行ってコードを変更します。

    kotlin
    package com.example.ktor
    
    import androidx.compose.ui.unit.DpSize
    import androidx.compose.ui.unit.dp
    import androidx.compose.ui.window.Window
    import androidx.compose.ui.window.WindowPosition
    import androidx.compose.ui.window.WindowState
    import androidx.compose.ui.window.application
    
    fun main() = application {
        val state = WindowState(
            size = DpSize(400.dp, 600.dp),
            position = WindowPosition(200.dp, 100.dp)
        )
        Window(
            title = "Task Manager (Desktop)",
            state = state,
            onCloseRequest = ::exitApplication,
        ) {
            App()
        }
    }
  12. app [hot] 🔥 実行構成を使用してデスクトップアプリケーションを実行します。 デスクトップで実行中のアプリ

  13. 次のいずれかの実行構成を使用してWebクライアントを実行します。

    • app [js]: Kotlin/JSアプリケーションを実行します。
    • app [wasmJs]: Kotlin/Wasmアプリケーションを実行します。
    Webで実行中のアプリ

UIの改善

クライアントはサーバーと通信できるようになりましたが、このままではUIが魅力的とは言えません。

  1. app/shared/src/commonMain/.../ktor にある App.kt ファイルを開き、既存の App を以下の App および TaskCard コンポーザブルに置き換えます。

    fun App() { {...}
    kotlin
    package com.example.ktor
    
    import com.example.ktor.network.TaskApi
    import com.example.ktor.model.Priority
    import com.example.ktor.model.Task
    import androidx.compose.foundation.layout.Column
    import androidx.compose.foundation.layout.Row
    import androidx.compose.foundation.layout.Spacer
    import androidx.compose.foundation.layout.fillMaxSize
    import androidx.compose.foundation.layout.fillMaxWidth
    import androidx.compose.foundation.layout.padding
    import androidx.compose.foundation.layout.safeContentPadding
    import androidx.compose.foundation.layout.width
    import androidx.compose.foundation.lazy.LazyColumn
    import androidx.compose.foundation.lazy.items
    import androidx.compose.foundation.shape.CornerSize
    import androidx.compose.foundation.shape.RoundedCornerShape
    import androidx.compose.material3.Card
    import androidx.compose.material3.MaterialTheme
    import androidx.compose.material3.OutlinedButton
    import androidx.compose.material3.Text
    import androidx.compose.runtime.*
    import androidx.compose.ui.Modifier
    import androidx.compose.ui.text.font.FontWeight
    import androidx.compose.ui.unit.dp
    import androidx.compose.ui.unit.sp
    import com.example.ktor.network.createHttpClient
    import kotlinx.coroutines.launch
    
    @Composable
    fun App() {
        MaterialTheme {
            val httpClient = createHttpClient()
            val taskApi = remember { TaskApi(httpClient) }
            var tasks by remember { mutableStateOf(emptyList<Task>()) }
            val scope = rememberCoroutineScope()
    
            LaunchedEffect(Unit) {
                tasks = taskApi.getAllTasks()
            }
    
            LazyColumn(
                modifier = Modifier
                    .safeContentPadding()
                    .fillMaxSize()
            ) {
                items(tasks) { task ->
                    TaskCard(
                        task,
                        onDelete = {
                            scope.launch {
                                taskApi.removeTask(it)
                                tasks = taskApi.getAllTasks()
                            }
                        },
                        onUpdate = {
                        }
                    )
                }
            }
        }
    }
    
    @Composable
    fun TaskCard(
        task: Task,
        onDelete: (Task) -> Unit,
        onUpdate: (Task) -> Unit
    ) {
        fun pickWeight(priority: Priority) = when (priority) {
            Priority.Low -> FontWeight.SemiBold
            Priority.Medium -> FontWeight.Bold
            Priority.High, Priority.Vital -> FontWeight.ExtraBold
        }
    
        Card(
            modifier = Modifier.fillMaxWidth().padding(4.dp),
            shape = RoundedCornerShape(CornerSize(4.dp))
        ) {
            Column(modifier = Modifier.padding(10.dp)) {
                Text(
                    "${task.name}: ${task.description}",
                    fontSize = 20.sp,
                    fontWeight = pickWeight(task.priority)
                )
    
                Row {
                    OutlinedButton(onClick = { onDelete(task) }) {
                        Text("Delete")
                    }
                    Spacer(Modifier.width(8.dp))
                    OutlinedButton(onClick = { onUpdate(task) }) {
                        Text("Update")
                    }
                }
            }
        }
    }

    この実装により、クライアントに基本的な機能が備わりました。

    LaunchedEffect 型を使用することで起動時にすべてのタスクが読み込まれ、LazyColumn コンポーザブルによってユーザーはタスクをスクロールできるようになります。

    最後に、独立した TaskCard コンポーザブルが作成され、これ自体が Card を使用して各 Task の詳細を表示します。タスクを削除および更新するためのボタンも追加されています。

  2. クライアントアプリケーション(たとえばAndroidアプリ)を再実行します。 タスクをスクロールしたり、詳細を表示したり、削除したりできるようになりました。 改善されたUIでAndroid上で実行中のアプリ

更新機能の追加

クライアントを完成させるために、タスクの詳細を更新できる機能を組み込みます。

  1. app/shared/src/commonMain/.../ktor にある App.kt ファイルに移動します。
  2. 以下に示すように、UpdateTaskDialog コンポーザブルと必要なインポートを追加します。

    kotlin
    import androidx.compose.material3.TextField
    import androidx.compose.material3.TextFieldDefaults
    import androidx.compose.ui.graphics.Color
    import androidx.compose.ui.window.Dialog
    
    @Composable
    fun UpdateTaskDialog(
        task: Task,
        onConfirm: (Task) -> Unit
    ) {
        var description by remember { mutableStateOf(task.description) }
        var priorityText by remember { mutableStateOf(task.priority.toString()) }
        val colors = TextFieldDefaults.colors(
            focusedTextColor = Color.Blue,
            focusedContainerColor = Color.White,
        )
    
        Dialog(onDismissRequest = {}) {
            Card(
                modifier = Modifier.fillMaxWidth().padding(4.dp),
                shape = RoundedCornerShape(CornerSize(4.dp))
            ) {
                Column(modifier = Modifier.padding(10.dp)) {
                    Text("Update ${task.name}", fontSize = 20.sp)
                    TextField(
                        value = description,
                        onValueChange = { description = it },
                        label = { Text("Description") },
                        colors = colors
                    )
                    TextField(
                        value = priorityText,
                        onValueChange = { priorityText = it },
                        label = { Text("Priority") },
                        colors = colors
                    )
                    OutlinedButton(onClick = {
                        val newTask = Task(
                            task.name,
                            description,
                            try {
                                Priority.valueOf(priorityText)
                            } catch (e: IllegalArgumentException) {
                                Priority.Low
                            }
                        )
                        onConfirm(newTask)
                    }) {
                        Text("Update")
                    }
                }
            }
        }
    }

    これは、ダイアログボックスで Task の詳細を表示するコンポーザブルです。description と priority は TextField コンポーザブル内に配置されているため、更新可能です。ユーザーが更新ボタンを押すと、onConfirm() コールバックがトリガーされます。

  3. 同じファイル内の App コンポーザブルを更新します。

    kotlin
    @Composable
    fun App() {
        MaterialTheme {
            val httpClient = createHttpClient()
            val taskApi = remember { TaskApi(httpClient) }
            var tasks by remember { mutableStateOf(emptyList<Task>()) }
            val scope = rememberCoroutineScope()
            var currentTask by remember { mutableStateOf<Task?>(null) }
    
            LaunchedEffect(Unit) {
                tasks = taskApi.getAllTasks()
            }
    
            if (currentTask != null) {
                UpdateTaskDialog(
                    currentTask!!,
                    onConfirm = {
                        scope.launch {
                            taskApi.updateTask(it)
                            tasks = taskApi.getAllTasks()
                        }
                        currentTask = null
                    }
                )
            }
    
            LazyColumn(modifier = Modifier
                .safeContentPadding()
                .fillMaxSize()
            ) {
                items(tasks) { task ->
                    TaskCard(
                        task,
                        onDelete = {
                            scope.launch {
                                taskApi.removeTask(it)
                                tasks = taskApi.getAllTasks()
                            }
                        },
                        onUpdate = {
                            currentTask = task
                        }
                    )
                }
            }
        }
    }

    ここでは追加の状態として、現在選択されているタスクを保持します。この値が null でない場合、UpdateTaskDialog コンポーザブルを呼び出し、TaskApi を使用してサーバーにPOSTリクエストを送信するように onConfirm() コールバックを設定します。

    最後に、TaskCard コンポーザブルを作成する際に、onUpdate() コールバックを使用して currentTask 状態変数を設定します。

  4. クライアントアプリケーションを再実行します。ボタンを使用して各タスクの詳細を更新できるようになっているはずです。 Androidでのタスクの削除

次のステップ

この記事では、Kotlin Multiplatformアプリケーションのコンテキスト内でKtorを使用しました。これで、さまざまなプラットフォームをターゲットとした複数のサービスとクライアントを含むプロジェクトを作成できるようになりました。

見てきたように、コードの重複や無駄なしに機能を構築することが可能です。プロジェクトの全レイヤーで必要とされる型は core マルチプラットフォームモジュール内に配置できます。サービスでのみ必要な機能は server モジュールに配置し、クライアントでのみ必要な機能は app モジュールに配置します。

このような開発には必然的にクライアントとサーバーの両方の技術に関する知識が必要となります。しかし、Kotlin MultiplatformライブラリとCompose Multiplatformを使用すれば、新しく学習しなければならない内容を最小限に抑えることができます。最初は単一のプラットフォームのみに焦点を当てている場合でも、アプリケーションの需要が高まるにつれて他のプラットフォームを簡単に追加できます。