MENU
  1. ホーム
  2. Kotlin
  3. Kotlin Nativeのexpectとactualの使い方を完全解説

Kotlin Nativeのexpectとactualの使い方を完全解説

Kotlin

Kotlinは、そのマルチプラットフォーム機能により、Android開発だけでなく、さまざまな環境で利用されています。その中でもKotlin Nativeは、iOSやLinux、Windowsなど、JVM以外のプラットフォーム向けにコードを動作させるための強力なツールです。このKotlin Nativeの特徴的な機能である「期待（expect）」と「実現（actual）」は、共通コードとプラットフォーム固有コードを効率的に切り分けることを可能にします。本記事では、expectとactualを活用して、Kotlin Nativeでのマルチプラットフォーム開発をどのように効率化できるかを詳しく解説します。

目次

Kotlin Nativeの基本概要


Kotlin Nativeは、KotlinコードをJVMに依存せずにネイティブバイナリにコンパイルするためのツールチェーンです。これにより、iOSやLinux、Windows、さらにはWebAssembly（WASM）など、さまざまなプラットフォーム上で動作するアプリケーションを構築できます。

Kotlin Nativeの特徴


Kotlin Nativeは、以下の特徴を持っています：

  • ネイティブコードへのコンパイル：JVMが必要なく、ネイティブコードとして動作します。
  • マルチプラットフォーム開発：共通コードを使用しつつ、プラットフォーム固有のコードを切り分けて実装できます。
  • 相互運用性：CやObjective-C、Swiftなどのコードと簡単に統合可能です。

利点


Kotlin Nativeを利用する主な利点は以下の通りです：

  • 効率的な開発：コードの再利用性が高まり、メンテナンスコストが削減されます。
  • パフォーマンス：ネイティブコードに直接コンパイルされるため、JVMを使用する場合と比べて効率的に動作します。
  • 幅広いプラットフォーム対応：一つのコードベースで複数のプラットフォームに対応可能です。

Kotlin Nativeは、Kotlin Multiplatformプロジェクトの一部として、期待と実現の仕組みを通じてプラットフォームごとに異なる実装を簡潔に管理できるようになっています。

expectとactualの基本概念

Kotlin Multiplatform開発では、プラットフォームに依存しない共通コードを記述しながら、必要に応じてプラットフォーム固有のコードを実装する必要があります。このような仕組みを実現するために用いられるのが、expectとactualです。

expectとactualとは

  • expect: 共通モジュールで宣言される「期待」コードです。これにより、プラットフォームに依存しないAPIや構造を記述できます。
  • actual: 各プラットフォームにおいて「実現」されるコードです。expectで定義されたAPIを、それぞれのプラットフォームに適した形で実装します。

expectとactualの役割


この仕組みは、共通コードを最大限に活用しつつ、プラットフォーム固有の実装を必要最小限に抑えるために設計されています。例えば、共通モジュールで定義されたクラスや関数を期待として宣言し、それをiOSやAndroidなど各プラットフォームごとに具体的に実現できます。

基本的な使用フロー

  1. expectの定義: 共通モジュールで期待されるクラスや関数を宣言します。
  2. actualの実装: プラットフォームモジュールで期待に応じた具体的な実装を記述します。
  3. ビルド時に統合: プロジェクト全体がビルドされる際に、各プラットフォームの実現が期待にマッピングされます。

このexpect/actualの仕組みにより、開発者は一貫した構造を維持しながら、柔軟にプラットフォーム固有の実装を追加できます。これがKotlin Multiplatformの強力な機能の一つです。

期待（expect）を用いた宣言の書き方

Kotlin Multiplatformプロジェクトでは、共通モジュールでプラットフォームに依存しないAPIや構造を宣言するためにexpectキーワードを使用します。このセクションでは、expect宣言の文法と具体的な使用例を解説します。

expectの基本構文


expect宣言は、クラス、関数、プロパティ、型エイリアスなど、さまざまな要素に対して使用できます。以下に基本的な構文を示します。

// 共通モジュール内
expect class SampleClass {
    fun platformSpecificFunction(): String
}

上記の例では、SampleClassとその中の関数platformSpecificFunctionが期待として宣言されています。これらの具体的な実装は、プラットフォームモジュールで提供される必要があります。

expectの使用例


実際のプロジェクトでは、次のように使用されます：

// 共通モジュール内
expect fun getPlatformName(): String

この場合、getPlatformName関数は期待として宣言され、各プラットフォームでその実装が提供されます。

expectを使用する際の注意点

  • プラットフォームごとの一致: expectで宣言された構造とactualの実装は、名前やシグネチャが一致している必要があります。
  • 使用場所: expectは共通モジュールでのみ使用できます。
  • 必須の実現: 全てのexpect宣言には、対応するactualの実装が各プラットフォームモジュールに存在する必要があります。

コード例: expectでのクラス宣言


以下は、プラットフォーム固有の日時処理を共通化する例です。

// 共通モジュール内
expect class DateTimeProvider {
    fun getCurrentDateTime(): String
}

この例では、DateTimeProviderクラスが日時を取得する機能を提供することを期待して宣言されています。この期待に対する実現（actual）は、各プラットフォームモジュールで実装する必要があります。

expect宣言を正しく使用することで、コードの再利用性と可読性を高め、マルチプラットフォーム開発を効率化できます。

実現（actual）の具体的な実装方法

Kotlin Multiplatformプロジェクトにおいて、共通モジュールで宣言された期待（expect）は、プラットフォームモジュールでactualとして具体的に実装されます。このセクションでは、actualの基本構文や実装方法を詳しく解説します。

actualの基本構文


actualは、プラットフォームごとのコードモジュール内でexpect宣言に対応する形で実装されます。以下は基本的な構文です：

// プラットフォームモジュール内
actual class SampleClass {
    actual fun platformSpecificFunction(): String {
        return "This is platform-specific implementation."
    }
}

上記の例では、SampleClassとその関数platformSpecificFunctionがプラットフォーム固有のロジックで実装されています。

実装の例

1. 関数の実装

共通モジュールで期待された関数の具体的な実装例です。

// 共通モジュール内
expect fun getPlatformName(): String

この期待に対して、以下のようにプラットフォーム固有の実現を提供します：

// iOSモジュール内
actual fun getPlatformName(): String {
    return "iOS"
}

// Androidモジュール内
actual fun getPlatformName(): String {
    return "Android"
}

2. クラスの実装

クラスのexpect宣言に対するactualの実装例です。

// 共通モジュール内
expect class DateTimeProvider {
    fun getCurrentDateTime(): String
}

これを以下のように各プラットフォームで実現します：

// iOSモジュール内
actual class DateTimeProvider {
    actual fun getCurrentDateTime(): String {
        return "Current time in iOS: ${NSDate().description}"
    }
}

// Androidモジュール内
actual class DateTimeProvider {
    actual fun getCurrentDateTime(): String {
        return "Current time in Android: ${System.currentTimeMillis()}"
    }
}

3. プロパティの実現

プロパティもexpectで宣言し、actualで実装可能です。

// 共通モジュール内
expect val platform: String

これを以下のように実現します：

// iOSモジュール内
actual val platform: String = "iOS"

// Androidモジュール内
actual val platform: String = "Android"

actualの実装時の注意点

  • 一致性: expectで宣言されたシグネチャ（関数名、引数、戻り値）と完全に一致している必要があります。
  • モジュール配置: actualの実装は、対応するプラットフォームモジュール内で行います。
  • 動作確認: 実装が正しいかを確認するため、必ずターゲットプラットフォームでビルドしてテストしてください。

actualの実装を正しく行うことで、共通コードとプラットフォーム固有コードが統合され、スムーズなマルチプラットフォーム開発が実現します。

プラットフォームごとの適応の仕方

Kotlin Multiplatformプロジェクトでは、共通コードを記述しながら、プラットフォームごとの違いに対応する必要があります。expectとactualを活用して、各プラットフォームに適応する具体的な方法を見ていきます。

プラットフォームモジュールの概要


Kotlin Multiplatformプロジェクトでは、以下のようなモジュール構造で開発が進められます：

  1. 共通モジュール: プラットフォームに依存しないコードを記述する部分。
  2. プラットフォームモジュール: 各プラットフォーム固有のコードを記述する部分。

これらを組み合わせてプロジェクトを構成することで、効率的に開発が行えます。

各プラットフォームでの適応例

1. iOSでの適応例

iOSモジュールでは、Objective-CやSwiftと連携するコードをactualとして実装します。

// 共通モジュール内
expect fun getPlatformInfo(): String

iOSモジュールでの実現：

// iOSモジュール内
actual fun getPlatformInfo(): String {
    return "Running on iOS: ${UIDevice.current.systemVersion}"
}

この例では、UIDeviceクラスを使用して、iOSデバイスの情報を取得しています。

2. Androidでの適応例

Androidモジュールでは、JavaやAndroidフレームワークのコードを使用して実現します。

// 共通モジュール内
expect fun getPlatformInfo(): String

Androidモジュールでの実現：

// Androidモジュール内
actual fun getPlatformInfo(): String {
    return "Running on Android: ${Build.VERSION.RELEASE}"
}

この実装では、Build.VERSION.RELEASEを使用してAndroidバージョンを取得しています。

適応のベストプラクティス

  • 共通コードを優先: 最大限共通モジュールでコードを記述し、プラットフォーム固有のコードを最小限に抑えます。
  • プラットフォームAPIの活用: 各プラットフォームに特化した機能を使用して最適化されたコードを実装します。
  • ユニットテストの活用: 各プラットフォームごとの適応が正しく機能しているかを確認するため、テストコードを作成します。

複数プラットフォーム間の互換性の確認

  • Kotlin Nativeでは、ターゲットプラットフォームごとにビルドプロセスが異なるため、各プラットフォームでのビルドと動作確認が重要です。
  • CI/CDツールを活用して、複数プラットフォームでのビルドを自動化することで効率化できます。

プラットフォーム固有の実装を適切に行うことで、共通コードを活用しながら、ネイティブな体験を提供するアプリケーションを構築できます。

共通コードとプラットフォーム固有コードの分離方法

Kotlin Multiplatformプロジェクトでは、共通コード（Common Code）とプラットフォーム固有コード（Platform-Specific Code）を明確に分離することで、コードの再利用性を高めながら効率的に開発を進めることができます。このセクションでは、分離のベストプラクティスと実践的な方法を解説します。

共通コードの役割と配置


共通コードは、プラットフォームに依存しないロジックや機能を記述する部分です。以下のような内容が含まれます：

  • ビジネスロジック
  • データモデル
  • 共通のユーティリティ関数

これらのコードは、共通モジュール（通常はcommonMain）に配置されます。

例: 共通コードのサンプル

// commonMain内
expect fun getDeviceName(): String

fun greetUser(): String {
    return "Hello from ${getDeviceName()}"
}

このように、プラットフォーム固有の情報（getDeviceName）はexpectとして抽象化し、それ以外のロジック（greetUser）は共通コードとして記述します。

プラットフォーム固有コードの役割と配置


プラットフォーム固有コードは、特定のプラットフォームでしか動作しないAPIやロジックを実装します。これらはiosMainやandroidMainなどのプラットフォーム別ディレクトリに配置されます。

例: プラットフォーム固有コードの実装

// iosMain内
actual fun getDeviceName(): String {
    return UIDevice.current.name
}

// androidMain内
actual fun getDeviceName(): String {
    return Build.MODEL
}

共通コードとプラットフォーム固有コードの分離のベストプラクティス

  1. 依存性の逆転（Dependency Inversion）を活用
    共通コードからプラットフォーム固有コードを直接参照しないようにし、expect/actualの抽象化を利用します。
  2. モジュール構成を整理
  • 共通モジュール: プラットフォーム非依存のロジックを集中させる。
  • プラットフォームモジュール: 必要最小限の固有ロジックを実装する。
  1. 明確な抽象化
    プラットフォーム固有の機能は、expect/actualを使って明確に分離します。

分離のメリット

  • コードの再利用性向上: 共通コードを複数のプラットフォームで再利用できます。
  • メンテナンスの容易さ: プラットフォーム固有の変更が共通ロジックに影響しません。
  • 開発効率の向上: チームメンバーが並行して開発しやすくなります。

共通コードとプラットフォーム固有コードを適切に分離することで、開発効率とコードの品質を両立させることができます。

トラブルシューティングとデバッグ方法

Kotlin Multiplatformプロジェクトでの開発では、expect/actualのミスマッチやプラットフォームごとの違いに起因する問題が発生することがあります。このセクションでは、よくある問題とその解決方法、さらに効率的なデバッグ手法を解説します。

よくある問題と解決方法

1. expectとactualの不一致

問題: expectで宣言されたAPIとactualで実装されたAPIが一致しない場合、ビルド時にエラーが発生します。

解決方法:

  • 共通モジュールのexpect宣言とプラットフォームモジュールのactual実装が、名前、引数、戻り値の型で一致していることを確認します。
  • IDEの補完機能を活用して、シグネチャを確認しながら実装します。

例: 不一致エラーの修正

// 共通モジュール内
expect fun getPlatformName(): String

// Androidモジュール内（修正前）
actual fun getPlatformName(): Int { // エラー
    return 42
}

// Androidモジュール内（修正後）
actual fun getPlatformName(): String {
    return "Android"
}

2. 実装漏れ

問題: expectで宣言された関数やクラスのactual実装が一部のプラットフォームで提供されていない場合、ビルドエラーが発生します。

解決方法:

  • 全てのターゲットプラットフォームでactualの実装が存在していることを確認します。
  • 実装が不要な場合でも、空のactualを記述することでエラーを回避します。

例: 空のactualを使用した解決

// 共通モジュール内
expect fun optionalFeature(): String

// プラットフォームモジュール内（実装不要な場合）
actual fun optionalFeature(): String {
    return "Not supported"
}

3. プラットフォーム依存のランタイムエラー

問題: 共通モジュールで使用されているライブラリやコードが、一部のプラットフォームでサポートされていない場合に実行時エラーが発生します。

解決方法:

  • プラットフォーム依存のコードはexpect/actualで分離します。
  • プラットフォームに特化したライブラリを活用します（例: iOSではFoundation、AndroidではJavaライブラリを利用）。

デバッグの効率的な方法

1. プラットフォーム固有のデバッガを活用

  • Android Studio: Androidのコードをデバッグするための専用ツール。
  • Xcode: iOSのコードをデバッグするためのIDE。
  • LLDB: Kotlin Nativeコードをデバッグするための標準ツール。

2. ログ出力での確認

  • 各プラットフォームでのログ出力を活用して、問題の発生箇所を特定します。

例: 共通のログ関数を定義

expect fun logMessage(message: String)

// iOSモジュール内
actual fun logMessage(message: String) {
    NSLog(message)
}

// Androidモジュール内
actual fun logMessage(message: String) {
    Log.d("Debug", message)
}

3. ユニットテストでの検証

  • 共通コードとプラットフォーム固有コードそれぞれにユニットテストを実装して、問題の再発を防止します。
  • Gradleを利用して、複数プラットフォームでのテストを自動化します。

CI/CDツールでの検証自動化


JenkinsやGitHub Actionsを利用して、コードの変更が各プラットフォームで正しく動作するかを自動的に検証する環境を構築します。これにより、デバッグ効率が大幅に向上します。

これらの手法を活用することで、開発中の問題を迅速に解決し、プロジェクト全体の品質を向上させることができます。

実践例: Kotlin Nativeアプリの構築

ここでは、Kotlin Nativeを活用して簡単なマルチプラットフォームアプリを構築する例を通じて、expectとactualをどのように使用するかを学びます。具体的には、プラットフォームごとに異なる日時情報を表示するアプリを作成します。

プロジェクトの概要


目的:

  • Kotlin Multiplatformプロジェクトを作成し、共通コードとプラットフォーム固有コードを分離する。
  • expect/actualを活用して、iOSとAndroidで異なる日時フォーマットを取得する。

完成後のアプリ動作:

  • iOSではYYYY/MM/DD HH:mm形式で日時を表示。
  • AndroidではYYYY-MM-DD HH:mm:ss形式で日時を表示。

Step 1: プロジェクトの初期設定

  1. Kotlin MultiplatformプロジェクトをGradleで作成します。
  2. 共通モジュール（commonMain）とプラットフォーム固有モジュール（androidMain、iosMain）を構成します。

Gradleスクリプトの例:

kotlin {
    android()
    ios()
    sourceSets {
        val commonMain by getting
        val androidMain by getting
        val iosMain by getting
    }
}

Step 2: 共通モジュールでexpectを定義


共通モジュールで日時を取得する関数を期待（expect）として宣言します。

// commonMain
expect fun getCurrentDateTime(): String

fun displayDateTime(): String {
    return "Current DateTime: ${getCurrentDateTime()}"
}

Step 3: プラットフォーム固有モジュールでactualを実装

iOSモジュールでの実装

// iosMain
import platform.Foundation.NSDateFormatter
import platform.Foundation.NSDate

actual fun getCurrentDateTime(): String {
    val formatter = NSDateFormatter().apply {
        dateFormat = "yyyy/MM/dd HH:mm"
    }
    return formatter.stringFromDate(NSDate())
}

Androidモジュールでの実装

// androidMain
import java.text.SimpleDateFormat
import java.util.Date
import java.util.Locale

actual fun getCurrentDateTime(): String {
    val formatter = SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.getDefault())
    return formatter.format(Date())
}

Step 4: 共通コードを使用してアプリを構築


各プラットフォームで共通コードを呼び出して、日時情報を表示するロジックを実装します。

iOSでの呼び出し

import UIKit
import shared // Kotlinコードのモジュール名

class ViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        let label = UILabel()
        label.text = KotlinMultiplatformKt.displayDateTime()
        label.textAlignment = .center
        label.frame = self.view.frame
        self.view.addSubview(label)
    }
}

Androidでの呼び出し

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import kotlinx.android.synthetic.main.activity_main.*
import com.example.shared.displayDateTime

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        textView.text = displayDateTime()
    }
}

Step 5: ビルドと実行


それぞれのプラットフォーム環境でアプリをビルドして動作を確認します。

  • iOS: Xcodeでビルドし、シミュレーターまたはデバイスで実行。
  • Android: Android Studioでビルドし、エミュレーターまたは実機で実行。

この例から学べること

  • expect/actualを活用することで、共通コードを保ちながらプラットフォーム固有の機能を実装できる。
  • Kotlin Multiplatformのモジュール構成により、複雑なアプリケーションでも効率的に開発できる。

この手法を応用することで、より大規模なマルチプラットフォームプロジェクトを効率的に構築できます。

まとめ

本記事では、Kotlin Nativeで期待（expect）と実現（actual）を活用してマルチプラットフォーム開発を効率化する方法を解説しました。expect/actualの基本概念から、共通コードとプラットフォーム固有コードの分離、実践例までを詳しく紹介しました。

適切にexpect/actualを活用すれば、コードの再利用性が向上し、異なるプラットフォーム向けに最適化されたアプリケーションを効率的に構築できます。これにより、開発時間を短縮し、メンテナンス性の高いプロジェクトを実現できます。ぜひ、自身のプロジェクトでもKotlin Nativeの機能を取り入れてみてください。

Kotlin
プログラミング マルチプラットフォーム Kotlin Native

コメント

コメントする

目次