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を作成します。
- IntelliJ IDEAを起動します。
- IntelliJ IDEAで、 File | New | Project を選択します。
- 左側のパネルで Kotlin Multiplatform を選択します。
- New Project ウィンドウで以下のフィールドを指定します。
- Name : full-stack-task-manager
- Project ID : com.example.ktor
ターゲットプラットフォームとして Android 、 Desktop 、 Web 、および Server を選択します。
Macを使用している場合は、 iOS も選択します。その際、 Share UI オプションが選択されていることを確認してください。

Create ボタンをクリックし、IDEがプロジェクトを生成およびインポートするのを待ちます。
サービスの実行
- IntelliJ IDEAで、 ApplicationKt 実行構成を選択します。

- Run ボタン (
) をクリックして構成を実行します。
Run ツールウィンドウに新しいタブが開きます。
http://0.0.0.0:8080/ にアクセスしてアプリケーションを開きます。 ブラウザにKtorからのメッセージが表示されるはずです。

プロジェクトの構造を確認する
server フォルダは、プロジェクト内にある3つのKotlinモジュールのうちの1つです。他の2つは core と app です。
server モジュールの構造は、Ktor Project Generatorで生成されるものと非常によく似ています。 プラグインと依存関係を宣言するための専用ビルドファイルがあり、Ktorサービスをビルドして起動するためのコードを含むソースセットが存在します。

Application.kt ファイル内のルーティングの指示を見ると、sayHello() 関数の呼び出しがあります。
fun Application.module() {
routing {
get("/") {
call.respondText(sayHello("Ktor"))
}
}
}sayHello() 関数は core モジュールで定義されています。ここは、サーバーとすべての異なるクライアントプラットフォーム間で共有される共通コードを配置する場所です。
app/shared/src/commonMain モジュール内の Greeting.kt ファイルを開くと、そこでも sayHello() 関数が使用されていることがわかります。
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キーワードとともに宣言されています。kotlinpackage com.example.ktor interface Platform { val name: String } expect fun getPlatform(): Platformその後、以下に示すように、各ターゲットプラットフォームが
getPlatform()関数のactual宣言を提供します。kotlinpackage 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()kotlinpackage com.example.ktor import android.os.Build class AndroidPlatform : Platform { override val name: String = "Android ${Build.VERSION.SDK_INT}" } actual fun getPlatform(): Platform = AndroidPlatform()kotlinpackage com.example.ktor class JVMPlatform : Platform { override val name: String = "Java ${System.getProperty("java.version")}" } actual fun getPlatform(): Platform = JVMPlatform()kotlinpackage com.example.ktor class WasmPlatform : Platform { override val name: String = "Web with Kotlin/Wasm" } actual fun getPlatform(): Platform = WasmPlatform()
クライアントアプリケーションの実行
ターゲットの実行構成を実行することで、クライアントアプリケーションを起動できます。iOSシミュレータでアプリケーションを実行するには、以下の手順に従ってください。
- IntelliJ IDEAで、 iosApp 実行構成とシミュレートするデバイスを選択します。

- Run ボタン (
) をクリックして構成を実行します。
iOSアプリを実行すると、内部的にXcodeでビルドされ、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型を利用しているということだけです。
生成されたプロジェクトの構造を理解できたので、タスクマネージャーの機能を段階的に追加していきましょう。
モデル型の追加
まず、モデル型を追加し、クライアントとサーバーの双方がアクセスできるようにします。
- 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" } core/build.gradle.kts を開き、シリアライゼーションプラグインを追加します。
kotlinplugins { //... alias(libs.plugins.kotlinSerialization) }同じファイルで、 commonMain ソースセットに新しい依存関係を追加します。
kotlinsourceSets { commonMain.dependencies { // マルチプラットフォームの依存関係をここに配置します implementation(libs.kotlinx.serialization.json) } //... }- IntelliJ IDEAで、 Build | Sync Project with Gradle Files を選択して更新を適用します。Gradleのインポートが完了すると、 Task.kt ファイルが正常にコンパイルできるようになります。
- core/src/commonMain/kotlin/com/example/ktor へ移動し、 model という新しいパッケージを作成します。
- 新しいパッケージ内に、 Task.kt という新しいファイルを作成します。
優先度を表す enum と、タスクを表すクラスを追加します。
Taskクラスには、kotlinx.serializationライブラリのSerializable型が注釈されています。kotlinpackage 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 )
サーバーの作成
次の段階は、タスクマネージャーのサーバー実装を作成することです。
- server/src/main/kotlin/com/example/ktor フォルダに移動し、 model というサブパッケージを作成します。
このパッケージ内に新しい TaskRepository.kt ファイルを作成し、リポジトリ用の以下のインターフェースを追加します。
kotlinpackage 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 }同じパッケージ内に、次のクラスを含む InMemoryTaskRepository.kt という新しいファイルを作成します。
kotlinpackage 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 } }server/src/main/kotlin/.../Application.kt を開き、既存のコードを以下の実装に置き換えます。
kotlinpackage 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 プラグインを含む)を使用しているため、複数のコンパイルエラーが発生します。
- settings.gradle.kts を開き、Ktorバージョンカタログをインポートします。 kotlin
dependencyResolutionManagement { versionCatalogs { create("ktorLibs").from("io.ktor:ktor-version-catalog:3.6.1") } } サーバーモジュールのビルドファイル( server/build.gradle.kts )を開き、以下の依存関係を追加します。
kotlindependencies { //... implementation(ktorLibs.serialization.kotlinx.json) implementation(ktorLibs.server.contentNegotiation) implementation(ktorLibs.server.cors) }- 再度、メインメニューから Build | Sync Project with Gradle Files を選択します。 インポートが完了すると、
ContentNegotiation型およびjson()関数のインポートが正しく機能するようになります。 - サーバーを再実行します。ブラウザからルートにアクセスできるようになっているはずです。
クライアントの作成
クライアントがサーバーにアクセスできるようにするには、Ktor Clientを含める必要があります。これには3種類の依存関係が関係します。
- Ktor Clientのコア機能。
- ネットワーク処理を行うプラットフォーム固有のエンジン。
- コンテンツネゴシエーションとシリアライゼーションのサポート。
- 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型をクライアントに追加できます。 - メインメニューで Build | Sync Project with Gradle Files を選択して、 ビルドファイルの変更をインポートします。
- app/shared/src/commonMain/kotlin/com/example/ktor へ移動し、 network という新しいパッケージを作成します。
新しいパッケージ内に、クライアント設定用の新しい HttpClientManager.kt ファイルを作成します。
kotlinpackage 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 アドレス」を探します
- macOS:
同じ app/shared/.../network パッケージ内に、以下の実装を持つ新しい TaskApi.kt ファイルを作成します。
kotlinpackage 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) } } }app/shared/.../App.kt を開き、コードを以下の実装に置き換えます。 これにより、
TaskApi型を使用してサーバーからタスクのリストを取得し、各タスクの名前をカラム内に表示します。kotlinpackage 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) } } } }サーバーが実行されている状態で、iosApp 実行構成を実行してiOSアプリケーションをテストします。
Fetch Tasks ボタンをクリックして、タスクのリストを表示します。
このデモでは、わかりやすさのためにプロセスを簡略化しています。実際のアプリケーションでは、暗号化されていないデータをネットワーク経由で送信しないようにすることが極めて重要です。Androidプラットフォームでは、アプリケーションに明示的にネットワーク権限を付与し、平文でのデータの送受信を許可する必要があります。これらの権限を有効にするには、 app/androidApp/src/main/AndroidManifest.xml を開き、次の設定を追加します。
xml<manifest> ... <application android:usesCleartextTraffic="true"> ... ... </application> <uses-permission android:name="android.permission.INTERNET"/> </manifest>app.androidApp 実行構成を使用してAndroidアプリケーションを実行します。 これでAndroidクライアントも実行できるようになります。

デスクトップクライアントの場合は、コンテナとなるウィンドウにサイズとタイトルを割り当てます。 app/desktopApp/src/.../main.kt ファイルを開き、
titleの変更およびstateプロパティの設定を行ってコードを変更します。kotlinpackage 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() } }app [hot] 🔥 実行構成を使用してデスクトップアプリケーションを実行します。

次のいずれかの実行構成を使用してWebクライアントを実行します。
- app [js]: Kotlin/JSアプリケーションを実行します。
- app [wasmJs]: Kotlin/Wasmアプリケーションを実行します。

UIの改善
クライアントはサーバーと通信できるようになりましたが、このままではUIが魅力的とは言えません。
app/shared/src/commonMain/.../ktor にある App.kt ファイルを開き、既存の
Appを以下のAppおよびTaskCardコンポーザブルに置き換えます。fun App() { {...}
kotlinpackage 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の詳細を表示します。タスクを削除および更新するためのボタンも追加されています。クライアントアプリケーション(たとえばAndroidアプリ)を再実行します。 タスクをスクロールしたり、詳細を表示したり、削除したりできるようになりました。

更新機能の追加
クライアントを完成させるために、タスクの詳細を更新できる機能を組み込みます。
- app/shared/src/commonMain/.../ktor にある App.kt ファイルに移動します。
以下に示すように、
UpdateTaskDialogコンポーザブルと必要なインポートを追加します。kotlinimport 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()コールバックがトリガーされます。同じファイル内の
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状態変数を設定します。- クライアントアプリケーションを再実行します。ボタンを使用して各タスクの詳細を更新できるようになっているはずです。

次のステップ
この記事では、Kotlin Multiplatformアプリケーションのコンテキスト内でKtorを使用しました。これで、さまざまなプラットフォームをターゲットとした複数のサービスとクライアントを含むプロジェクトを作成できるようになりました。
見てきたように、コードの重複や無駄なしに機能を構築することが可能です。プロジェクトの全レイヤーで必要とされる型は core マルチプラットフォームモジュール内に配置できます。サービスでのみ必要な機能は server モジュールに配置し、クライアントでのみ必要な機能は app モジュールに配置します。
このような開発には必然的にクライアントとサーバーの両方の技術に関する知識が必要となります。しかし、Kotlin MultiplatformライブラリとCompose Multiplatformを使用すれば、新しく学習しなければならない内容を最小限に抑えることができます。最初は単一のプラットフォームのみに焦点を当てている場合でも、アプリケーションの需要が高まるにつれて他のプラットフォームを簡単に追加できます。

