MENU
  1. ホーム
  2. Kotlin
  3. Kotlin Multiplatformのexpect/actualを理解し活用する方法

Kotlin Multiplatformのexpect/actualを理解し活用する方法

Kotlin

Kotlin Multiplatformは、単一のコードベースから複数のプラットフォーム向けアプリケーションを開発できる革新的な技術です。その中でも、expect/actualという仕組みは、プラットフォーム間で共通コードを効率的に活用しつつ、特定プラットフォームごとの独自要件を柔軟に実現するための強力なツールです。本記事では、Kotlin Multiplatformの魅力を探りつつ、expect/actualの具体的な使用例を通じて、その設計意図や活用方法を詳しく解説していきます。これにより、Kotlin Multiplatformを利用した開発の幅をさらに広げることができるでしょう。

目次

Kotlin Multiplatformの基本概念


Kotlin Multiplatformは、JetBrainsが開発したKotlinプログラミング言語の拡張機能であり、iOS、Android、Web、デスクトップなどの複数プラットフォーム向けに単一のコードベースでアプリケーションを構築するためのフレームワークです。

マルチプラットフォーム開発の利点


Kotlin Multiplatformを利用することで、以下のようなメリットを得られます。

  • コードの再利用性：ビジネスロジックやデータモデルなど、プラットフォームに依存しない部分を1つのコードベースで記述できます。
  • 開発コストの削減：共通コードを再利用することで、複数プラットフォーム向けの開発コストを大幅に削減できます。
  • 柔軟性：プラットフォームごとのネイティブ機能にもアクセス可能で、アプリケーションの特性に応じた開発が可能です。

共通コードとプラットフォーム固有コード


Kotlin Multiplatformプロジェクトは、大きく次の2つの部分に分かれています。

  1. 共通コード（Common Code）
    共通ロジックやデータ構造、アルゴリズムなどを記述する部分です。このコードは、すべてのプラットフォームで再利用されます。
  2. プラットフォーム固有コード（Platform-Specific Code）
    各プラットフォーム固有のAPIや動作を実現するために記述する部分です。この部分は、共通コードと組み合わせてアプリケーションを完成させます。

Kotlin Multiplatformの仕組み


Kotlin Multiplatformは、Kotlinのコンパイラを利用して、各プラットフォームのネイティブコード（例えば、JVMバイトコードやiOSのネイティブコードなど）を生成します。この仕組みにより、プラットフォーム間でのコード共有が可能になり、同時に各プラットフォームの特性を最大限に活用することができます。

このように、Kotlin Multiplatformは、効率的かつ柔軟にマルチプラットフォームアプリケーションを構築できる強力なフレームワークとして注目されています。

expect/actualの概要

Kotlin Multiplatformの中核を成すexpect/actualは、プラットフォームごとの独自の実装をサポートしながらも、共通コードを効率的に活用するための仕組みです。この設計により、コードの再利用性を確保しつつ、各プラットフォーム固有の要件に柔軟に対応できます。

expect/actualの役割


expect/actualは、以下の役割を担っています。

  • 共通インターフェースの提供：expectを使用して、プラットフォーム間で共通の仕様やインターフェースを定義します。
  • プラットフォーム固有の実装：actualを使用して、各プラットフォームでの具体的な実装を記述します。

expectとactualの関係

  • expect
    共通コード内で、プラットフォームごとの具体的な実装が必要な箇所を抽象的に定義します。実装そのものではなく、仕様や契約を宣言するイメージです。
  • actual
    expectで定義された仕様を、プラットフォーム固有コード内で具体的に実装します。プラットフォームごとに異なるコードを記述できるため、柔軟な対応が可能です。

基本的な構文


以下は、expectとactualの基本構文です。

// 共通コード（commonMain）
expect class Platform() {
    fun getName(): String
}

// JVM固有コード（jvmMain）
actual class Platform {
    actual fun getName(): String {
        return "JVM"
    }
}

// iOS固有コード（iosMain）
actual class Platform {
    actual fun getName(): String {
        return "iOS"
    }
}

活用のメリット

  • プラットフォームごとの一貫性を確保
    共通コードから期待される仕様が明確に定義されるため、各プラットフォームでの実装が統一されます。
  • 開発の効率化
    共通コードとプラットフォーム固有コードを明確に分けることで、複雑なコードの管理が容易になります。

このように、expect/actualは、共通コードの再利用とプラットフォームごとの柔軟な対応を両立させるための強力な仕組みを提供しています。

expectとactualの使用例：シンプルなケース

expect/actualの基本的な使い方を、シンプルなケースを通じて解説します。今回は、異なるプラットフォームでの現在日時を取得する例を取り上げます。

共通コードの定義


共通コードでは、expectを用いて、プラットフォームごとの日時取得ロジックを抽象化します。

// 共通コード（commonMain）
expect fun getCurrentDateTime(): String

このexpect関数は、日時を文字列として返すことを期待しています。しかし、具体的な実装は含まれていません。

プラットフォーム固有の実装

JVMの実装


JVMでは、JavaのLocalDateTimeを用いて日時を取得します。

// JVM固有コード（jvmMain）
import java.time.LocalDateTime
import java.time.format.DateTimeFormatter

actual fun getCurrentDateTime(): String {
    val current = LocalDateTime.now()
    val formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")
    return current.format(formatter)
}

iOSの実装


iOSでは、NSDateFormatterを用いて日時を取得します。

// iOS固有コード（iosMain）
import platform.Foundation.NSDate
import platform.Foundation.NSDateFormatter
import platform.Foundation.NSLocale

actual fun getCurrentDateTime(): String {
    val dateFormatter = NSDateFormatter()
    dateFormatter.locale = NSLocale.currentLocale()
    dateFormatter.dateFormat = "yyyy-MM-dd HH:mm:ss"
    return dateFormatter.stringFromDate(NSDate())
}

実行結果


アプリケーションのコードでgetCurrentDateTimeを呼び出すと、それぞれのプラットフォームに応じた日時が取得されます。

fun main() {
    println("Current DateTime: ${getCurrentDateTime()}")
}
  • JVMでの出力例: 2024-12-18 14:35:00
  • iOSでの出力例: 2024-12-18 14:35:00

この例のポイント

  1. 共通コードの簡潔さ
    共通コードは、インターフェースのように期待する動作を定義するだけで済みます。
  2. プラットフォーム固有の最適化
    各プラットフォームのAPIを活用して、最適な実装が可能です。
  3. 再利用性の向上
    共通コードを利用する部分では、プラットフォームの違いを意識せずに開発できます。

このシンプルなケースを通じて、expect/actualの基本的な使い方を理解できるでしょう。次章では、より複雑な実践例を紹介します。

プラットフォームごとの実装管理

Kotlin Multiplatformでのexpect/actualを活用する際には、各プラットフォーム固有の実装を適切に管理することが重要です。この章では、実装を整理し、効率的に管理する方法を解説します。

ソースセットの構造


Kotlin Multiplatformプロジェクトでは、ディレクトリ構造に基づいてプラットフォーム固有のコードを管理します。以下は、典型的なプロジェクト構造の例です。

src/
├── commonMain/       // 共通コード
│   └── kotlin/       // expect定義
├── jvmMain/          // JVM固有コード
│   └── kotlin/       // actual実装
├── iosMain/          // iOS固有コード
│   └── kotlin/       // actual実装
  • commonMain: 共通コードとexpect定義を配置。
  • jvmMain, iosMain: 各プラットフォーム固有のactual実装を配置。

この構造に従うことで、コードが自動的に適切なターゲット向けにビルドされます。

プラットフォーム間の依存関係の分離


プラットフォーム固有の実装では、各プラットフォーム特有の依存関係を利用できます。以下に、Gradleを使用して依存関係を設定する例を示します。

kotlin {
    jvm() // JVMターゲット
    iosX64() // iOSターゲット

    sourceSets {
        val commonMain by getting {
            dependencies {
                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3")
            }
        }
        val jvmMain by getting {
            dependencies {
                implementation("com.squareup.okhttp3:okhttp:4.10.0")
            }
        }
        val iosMain by getting {
            dependencies {
                implementation("io.ktor:ktor-client-ios:2.3.4")
            }
        }
    }
}

このように、共通コードとプラットフォーム固有コードで異なるライブラリを設定できます。

リソースの管理


コード以外に、画像や文字列などのリソースもプラットフォームごとに管理する必要があります。リソース管理のポイントを以下に示します。

  • 共通リソース: 共通のリソースはcommonMainに配置。
  • 固有リソース: 各プラットフォーム用のリソースはjvmMainやiosMainなどに配置。

具体的には、次のようなコードでプラットフォーム固有リソースにアクセスできます。

expect fun getPlatformResource(): String

// JVM実装
actual fun getPlatformResource(): String {
    return "JVM Resource"
}

// iOS実装
actual fun getPlatformResource(): String {
    return "iOS Resource"
}

プラットフォームの選択を意識した設計


プラットフォーム固有の実装を管理する際は、以下の設計指針を心がけましょう。

  • 責務を分離する: 共通コードと固有コードの責務を明確に分ける。
  • 柔軟性を確保する: プラットフォームごとに異なるAPIや仕様に対応できる設計を採用する。
  • テスト可能性を考慮する: プラットフォーム固有コードがテスト可能な状態であることを確認する。

このステップの重要性


適切な実装管理により、プロジェクトの複雑さを軽減し、保守性を向上させることができます。特に、大規模なマルチプラットフォームプロジェクトでは、このような管理が成功の鍵となります。

実践的な使用例：ファイルI/Oの実装

expect/actualを使用して、異なるプラットフォームでのファイルI/O処理を実装する方法を解説します。この例では、共通コードでファイル読み書きのインターフェースを定義し、各プラットフォームで具体的な実装を行います。

共通コードの定義


共通コードで、ファイル操作のインターフェースをexpectとして定義します。

// 共通コード（commonMain）
expect class FileHandler(fileName: String) {
    fun write(content: String)
    fun read(): String
}

ここでは、FileHandlerクラスをexpectとして定義し、ファイルへの書き込みと読み込みの機能を提供することを期待しています。

プラットフォーム固有の実装

JVMの実装


JVMでは、標準のjava.ioパッケージを使用してファイル操作を実装します。

// JVM固有コード（jvmMain）
import java.io.File

actual class FileHandler actual constructor(private val fileName: String) {
    private val file = File(fileName)

    actual fun write(content: String) {
        file.writeText(content)
    }

    actual fun read(): String {
        return if (file.exists()) file.readText() else ""
    }
}

この実装では、Fileクラスを利用してファイルの読み書きを行います。

iOSの実装


iOSでは、NSFileManagerを使用して同様の機能を実装します。

// iOS固有コード（iosMain）
import platform.Foundation.*

actual class FileHandler actual constructor(private val fileName: String) {
    private val filePath: String = NSSearchPathForDirectoriesInDomains(
        NSDocumentDirectory, NSUserDomainMask, true
    ).first() + "/$fileName"

    actual fun write(content: String) {
        val data = content.encodeToByteArray().toNSData()
        NSFileManager.defaultManager.createFileAtPath(filePath, data, null)
    }

    actual fun read(): String {
        val file = NSFileManager.defaultManager.contentsAtPath(filePath)
        return file?.toByteArray()?.decodeToString() ?: ""
    }
}

ここでは、iOS固有のファイル管理APIを使用してファイル操作を実現しています。

使用例


共通コードを利用して、簡単なファイルの書き込みと読み込みを行うサンプルを示します。

fun main() {
    val fileHandler = FileHandler("sample.txt")

    // ファイルに書き込み
    fileHandler.write("Hello, Kotlin Multiplatform!")

    // ファイルから読み込み
    val content = fileHandler.read()
    println("File Content: $content")
}

実行結果

  • JVM環境: ファイルsample.txtに文字列が保存され、同じ内容が出力されます。
  • iOS環境: ドキュメントフォルダにファイルが作成され、内容が出力されます。

この実装のポイント

  1. 共通コードの再利用
    ファイル操作の基本機能は共通コードで利用可能です。
  2. プラットフォームごとの柔軟性
    各プラットフォームに最適化されたAPIを利用することで、効率的な実装が可能です。
  3. 保守性の向上
    expect/actualの仕組みにより、コードを簡潔に保ちながらプラットフォーム間の差異を吸収できます。

このように、expect/actualを使用することで、異なるプラットフォーム間で一貫性のあるファイル操作を実現できます。次章では、テスト方法を詳しく解説します。

テスト戦略

Kotlin Multiplatformでexpect/actualを使用したコードをテストするには、共通コードとプラットフォーム固有コードそれぞれに適切なテストを用意することが重要です。この章では、効率的なテスト戦略とベストプラクティスを解説します。

共通コードのテスト


共通コードのロジックは、プラットフォームに依存しないため、共通のテストケースを作成できます。以下は、FileHandlerを使用した例です。

// 共通コード（commonTest）
import kotlin.test.Test
import kotlin.test.assertEquals

class FileHandlerTest {
    @Test
    fun testFileWriteAndRead() {
        val fileHandler = FileHandler("testFile.txt")
        fileHandler.write("Test Content")
        val content = fileHandler.read()
        assertEquals("Test Content", content, "File content should match written content.")
    }
}

このテストは共通ロジックの動作確認に適しており、すべてのプラットフォームで再利用できます。

プラットフォーム固有コードのテスト

プラットフォーム特有の実装やAPIをテストする場合、それぞれのプラットフォームに特化したテストを作成する必要があります。

JVM環境のテスト


JVM固有のロジックをテストする場合、JVM専用のテストソースセットを利用します。

// JVM固有テスト（jvmTest）
import org.junit.Test
import kotlin.test.assertTrue

class JVMFileHandlerTest {
    @Test
    fun testJVMFileExists() {
        val fileHandler = FileHandler("jvmTestFile.txt")
        fileHandler.write("JVM Test Content")
        val fileExists = java.io.File("jvmTestFile.txt").exists()
        assertTrue(fileExists, "File should exist after writing content.")
    }
}

iOS環境のテスト


iOS固有のロジックをテストする場合、iOS専用のテストソースセットを利用します。

// iOS固有テスト（iosTest）
import kotlin.test.Test
import kotlin.test.assertTrue
import platform.Foundation.*

class IOSFileHandlerTest {
    @Test
    fun testIOSFileExists() {
        val fileName = "iosTestFile.txt"
        val fileHandler = FileHandler(fileName)
        fileHandler.write("iOS Test Content")
        val filePath = NSSearchPathForDirectoriesInDomains(
            NSDocumentDirectory, NSUserDomainMask, true
        ).first() + "/$fileName"
        val fileExists = NSFileManager.defaultManager.fileExistsAtPath(filePath)
        assertTrue(fileExists, "File should exist after writing content.")
    }
}

テスト戦略のベストプラクティス

  1. 共通テストの優先
    可能な限り共通コードにロジックを移し、共通テストで検証することでテスト重複を減らします。
  2. プラットフォーム固有テストの補完
    プラットフォーム依存のAPIや挙動については、それぞれの環境での固有テストを補完的に実施します。
  3. テスト環境の自動化
    CI/CDパイプラインを設定して、すべてのターゲットプラットフォームでテストを実行し、一貫した品質を確保します。

テスト結果の例


CI/CDパイプラインでの実行結果の例:

  • JVM: 全テストケース成功
  • iOS: 全テストケース成功

この戦略の重要性


適切なテスト戦略を採用することで、Kotlin Multiplatformプロジェクトの信頼性を向上させ、異なるプラットフォーム間での一貫性を確保できます。次章では、コードの保守性とリファクタリングについて解説します。

コードの保守性とリファクタリング

Kotlin Multiplatformプロジェクトでは、コードを長期的に保守しやすくするための設計とリファクタリングが重要です。この章では、expect/actualを利用したコードを効率的に保守し、リファクタリングを行う際のポイントを解説します。

保守性を高める設計の基本

責務の分離


共通コードとプラットフォーム固有コードの役割を明確に分離することが重要です。共通コードは汎用的なロジックに集中し、固有コードはプラットフォームの特性を活かした実装に限定します。

// 共通コード
expect class Logger() {
    fun log(message: String)
}

// プラットフォーム固有コード（例: JVM）
actual class Logger {
    actual fun log(message: String) {
        println("Log: $message")
    }
}

拡張性の確保


新しいプラットフォームが追加される可能性を考慮して、コードを柔軟に設計します。例えば、プラットフォーム間で共通するパターンを抽象化し、再利用性を向上させます。

リファクタリングの手法

重複コードの排除


共通化できる部分はcommonMainに移動し、プラットフォーム固有コードを最小限に抑えます。

リファクタリング前:

// JVM実装
actual fun getPlatformInfo(): String {
    return "Running on JVM"
}

// iOS実装
actual fun getPlatformInfo(): String {
    return "Running on iOS"
}

リファクタリング後:

// 共通コード
expect fun getPlatformName(): String

fun getPlatformInfo(): String {
    return "Running on ${getPlatformName()}"
}

// JVM固有コード
actual fun getPlatformName(): String = "JVM"

// iOS固有コード
actual fun getPlatformName(): String = "iOS"

コードのモジュール化


大規模なプロジェクトでは、共通コードをモジュールごとに分割することで保守性を向上させます。以下は、典型的なモジュール分割の例です。

src/
├── commonMain/
│   ├── logging/
│   │   └── Logger.kt
│   ├── networking/
│   │   └── HttpClient.kt

これにより、特定の機能やライブラリに変更が発生した際、影響を最小限に抑えることができます。

依存関係の整理


不要な依存関係を削除し、共通コードと固有コードそれぞれに必要な依存関係のみを含めます。

dependencies {
    commonMain {
        implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3")
    }
    jvmMain {
        implementation("com.squareup.okhttp3:okhttp:4.10.0")
    }
    iosMain {
        implementation("io.ktor:ktor-client-ios:2.3.4")
    }
}

リファクタリング後のテスト


リファクタリングを行った後は、以下の手順でテストを実施します。

  1. 単体テストの実行: すべてのユニットテストが成功することを確認します。
  2. 統合テストの実行: プラットフォーム間での連携が正しく動作するかを検証します。
  3. リグレッションテスト: リファクタリング前と同じ動作を維持していることを確認します。

リファクタリングの効果

  • コードの明確化: 冗長な部分が削減され、読みやすくなります。
  • 保守性の向上: 新しいプラットフォームや機能の追加が容易になります。
  • バグの減少: 共通コードの再利用により、バグが少なくなります。

結論


Kotlin Multiplatformのexpect/actualを活用したコードは、適切な設計とリファクタリングにより、長期的に保守しやすいプロジェクトに進化させることができます。次章では、開発時に直面しがちなトラブルシューティングの方法について解説します。

トラブルシューティング

Kotlin Multiplatformプロジェクトでexpect/actualを利用する際に発生しやすい問題と、その解決方法を解説します。これらの問題は、開発やビルドの過程で直面する可能性が高いため、事前に理解しておくことで効率的に対処できます。

よくある問題と解決策

問題1: `Unresolved reference: actual` エラー


このエラーは、expectとして定義された要素に対応するactual実装が見つからない場合に発生します。

原因:

  • プラットフォーム固有のソースセットにactualの実装が存在しない。
  • プラットフォーム固有コードが正しいターゲットに紐づけられていない。

解決策:

  1. 各プラットフォームのソースセットに正しく実装されているか確認します。
  2. Gradle設定でターゲットが正しく設定されているかを確認します。
   kotlin {
       jvm()
       iosX64()
   }

問題2: ライブラリの互換性問題


共通コードで利用しているライブラリが、特定のプラットフォームで非互換性を持つ場合があります。

原因:

  • 使用中のライブラリがすべてのターゲットプラットフォームをサポートしていない。

解決策:

  1. 共通コードで使用するライブラリを、すべてのプラットフォームで利用可能なものに限定します。
    例: kotlinx.coroutinesはMultiplatform対応です。
  2. 特定のプラットフォーム固有コードでのみ必要なライブラリは、該当プラットフォームのsourceSetに限定します。
   sourceSets {
       val jvmMain by getting {
           dependencies {
               implementation("com.squareup.okhttp3:okhttp:4.10.0")
           }
       }
   }

問題3: `expect`と`actual`の型の不一致


expectで定義された型と、actualで実装された型が一致しない場合に発生します。

原因:

  • expectで定義された構造や関数シグネチャに対して、actualが異なる型や引数を持つ。

解決策:

  1. expectとactualの定義を再確認し、完全に一致するよう修正します。
   // 共通コード
   expect fun fetchData(): String

   // JVM固有コード
   actual fun fetchData(): String {
       return "JVM Data"
   }

問題4: ビルドエラー「Missing required Kotlin/Native target」


Kotlin/Nativeターゲットを設定していない場合、ビルドが失敗することがあります。

原因:

  • Gradle設定でKotlin/Nativeターゲットが適切に有効化されていない。

解決策:

  1. GradleでKotlin/Nativeターゲットを明示的に指定します。
   kotlin {
       iosX64()
       iosArm64()
       iosSimulatorArm64()
   }

デバッグツールの活用

Gradleログの確認


Gradleの詳細なログを有効にし、問題の発生箇所を特定します。

./gradlew build --info

IDEの補助ツール


IntelliJ IDEAやAndroid Studioでは、以下の機能を利用してデバッグを効率化できます。

  • ソースセットビュー: 共通コードと固有コードの依存関係を可視化します。
  • ターゲット選択: ビルドターゲットごとのコードの切り替えが容易です。

トラブルを未然に防ぐためのベストプラクティス

  1. 一貫した構造を維持する
    expectとactualの定義を明確にし、すべてのプラットフォームで一貫性を保ちます。
  2. 自動テストの導入
    CI/CDパイプラインで、すべてのターゲットプラットフォームでのテストを自動化します。
  3. コミュニティリソースの活用
    Kotlin公式ドキュメントやGitHubリポジトリを参照し、最新のベストプラクティスを確認します。

結論


Kotlin Multiplatformでのトラブルシューティングは、問題を適切に分類し、適切なツールやアプローチを用いることで効率的に行えます。これにより、プロジェクト全体の開発体験が向上します。次章では、この記事の総まとめを行います。

まとめ

本記事では、Kotlin Multiplatformのexpect/actualの基本概念から、使用例、実装管理、テスト、保守性向上のためのリファクタリング、そしてトラブルシューティングまで、幅広く解説しました。expect/actualを活用することで、共通コードの再利用性を高めつつ、プラットフォーム固有の要件に柔軟に対応できるプロジェクトを構築できます。

適切な設計と管理を行うことで、コードの保守性が向上し、新たなプラットフォームへの対応も容易になります。また、トラブルシューティングの知識を活用することで、問題解決のスピードが上がり、開発効率が向上します。

Kotlin Multiplatformのexpect/actualを理解し、効果的に運用することで、マルチプラットフォーム開発の可能性をさらに広げていきましょう。

Kotlin
プログラミング Kotlin Multiplatform

コメント

コメントする

目次