MENU
  1. ホーム
  2. Kotlin
  3. KotlinでのDIスコープ設定方法をKoinで徹底解説

KotlinでのDIスコープ設定方法をKoinで徹底解説

Kotlin

Kotlinの依存性注入（DI）ライブラリであるKoinは、そのシンプルさと柔軟性で多くの開発者に支持されています。DIは、クラス間の依存関係を外部から注入することで、コードの保守性やテストの容易さを向上させる設計パターンです。Koinでは、DIの設定が容易で、特に「スコープ」機能を利用することで、依存オブジェクトのライフサイクルを効率的に管理できます。

本記事では、Koinのスコープ機能に焦点を当て、スコープの基本概念や設定方法、具体的なコード例、実践的な応用方法について詳しく解説します。Kotlinプロジェクトにおいて、適切にスコープを活用することで、アプリケーションのパフォーマンス向上やコードの品質改善が可能です。Koinを活用し、効率的な依存性管理を実現しましょう。

目次
  1. 依存性注入（DI）とは
    1. DIの基本概念
    2. KotlinにおけるDIのメリット
    3. DIライブラリの必要性
  2. Koinの概要と特徴
    1. Koinの基本的な特徴
    2. Koinの仕組み
    3. Koinと他のDIライブラリとの比較
  3. Koinにおけるスコープとは
    1. スコープの基本概念
    2. Koinスコープの利点
    3. スコープの基本構文
    4. スコープを使用する場面
  4. Koinスコープの基本的な使い方
    1. 1. スコープの作成
    2. 2. スコープの取得
    3. 3. 複数のスコープを管理
    4. 4. スコープの自動管理
    5. 5. スコープの破棄
    6. まとめ
  5. スコープのライフサイクル管理
    1. スコープのライフサイクルの基本
    2. スコープの生成と破棄
    3. ライフサイクルに基づくスコープ管理の例
    4. 自動ライフサイクル管理
    5. スコープ破棄時の注意点
    6. まとめ
  6. 実際のコード例：Koinでのスコープ実装
    1. 1. モジュールの作成
    2. 2. Activityでスコープを利用する
    3. 3. スコープ内で利用するクラス
    4. 4. Fragmentでスコープを利用する
    5. 5. Koinの初期化
    6. コード全体のまとめ
  7. スコープを活用したDIの応用例
    1. 1. 複数の画面間でのデータ共有
    2. 2. セッション管理
    3. 3. ダイアログ用の一時的なスコープ
    4. 4. ワークフロー単位でのスコープ管理
    5. まとめ
  8. Koinスコープでのよくあるエラーと対処法
    1. 1. スコープが見つからないエラー
    2. 2. 依存関係が解決できないエラー
    3. 3. スコープのライフサイクルが一致しないエラー
    4. 4. スコープ破棄後の依存取得エラー
    5. 5. 複数のスコープIDの競合
    6. まとめ
  9. まとめ

依存性注入（DI）とは


依存性注入（Dependency Injection、略してDI）とは、クラスが必要とする依存オブジェクトを外部から注入するデザインパターンです。これにより、クラス間の依存関係を柔軟に管理し、コードの保守性やテストの容易さが向上します。

DIの基本概念


通常、クラス内で必要な依存オブジェクトを直接生成すると、そのクラスは特定の実装に強く依存します。これにより、以下の問題が発生する可能性があります：

  • 変更が困難：依存するオブジェクトを変更するたびに、関連するコードも修正する必要があります。
  • テストが難しい：モックやスタブを使ったテストが難しくなります。
  • コードの密結合：依存関係がコード内にハードコーディングされるため、再利用性が低下します。

DIを導入することで、依存するオブジェクトを外部から提供する形になります。

KotlinにおけるDIのメリット


KotlinでDIを利用すると、次のメリットがあります：

  1. テストの容易さ：依存関係をモックやスタブに置き換えやすく、単体テストがしやすくなります。
  2. コードの再利用性：依存関係を簡単に差し替えることで、コードの再利用性が向上します。
  3. 保守性の向上：クラス間の結合度が低いため、変更が容易になります。

DIライブラリの必要性


手動でDIを実装することも可能ですが、DIライブラリを使うと設定や管理が効率的になります。Kotlinでよく使用されるDIライブラリには次のものがあります：

  • Koin：シンプルで学習コストが低いDIライブラリ。
  • Dagger：コンパイル時に依存関係を解決するため、高パフォーマンス。

この中でもKoinは、DSL（Domain-Specific Language）を活用し、設定が容易でシンプルなため、初心者から上級者まで幅広く利用されています。

Koinの概要と特徴


Koinは、Kotlin向けのシンプルで軽量な依存性注入（DI）ライブラリです。特に、シンプルな構文と設定の容易さで、Kotlin開発者に人気があります。KoinはDSL（Domain-Specific Language）を活用して依存関係を定義し、コードの保守性とテストの効率を向上させます。

Koinの基本的な特徴

  1. シンプルなDSL
    KoinはKotlinのDSLを使用して依存関係を定義します。XMLやアノテーションの必要がなく、コードのみで設定が完結します。
  2. ランタイム依存解決
    Koinはランタイムで依存関係を解決するため、コンパイル時の生成が不要です。これにより、動的な依存関係の管理が容易になります。
  3. シングルトンとファクトリのサポート
    シングルトンとしてインスタンスを管理する方法や、毎回新しいインスタンスを生成するファクトリ方式が選択できます。
  4. スコープ機能
    Koinではスコープを設定することで、依存オブジェクトのライフサイクルを管理できます。これにより、特定の処理や画面の範囲で依存オブジェクトを使い回すことが可能です。
  5. Androidとの親和性
    KoinはAndroidアプリ開発に最適化されており、ViewModelやActivity、Fragmentといったコンポーネントへの依存注入が簡単に行えます。

Koinの仕組み


Koinの依存性注入は、次の3つのステップで構成されます：

  1. モジュール定義
    依存関係を定義するKoinモジュールを作成します。
   val appModule = module {
       single { MyRepository() }
       factory { MyService(get()) }
   }
  1. Koinの開始
    アプリケーションクラスでKoinを起動し、モジュールをロードします。
   class MyApp : Application() {
       override fun onCreate() {
           super.onCreate()
           startKoin {
               modules(appModule)
           }
       }
   }
  1. 依存関係の注入
    必要な場所で依存関係を注入します。
   class MyViewModel(val service: MyService) : ViewModel()

Koinと他のDIライブラリとの比較

  • Koin：設定がシンプルで学習コストが低い。ランタイム依存解決。
  • Dagger：コンパイル時の依存解決で高パフォーマンス。設定がやや複雑。
  • Hilt：DaggerをベースにしたAndroid向けDIライブラリ。

Koinはシンプルさを重視する開発者や、小規模〜中規模プロジェクトに特に適しています。

Koinにおけるスコープとは


Koinにおける「スコープ」とは、特定のライフサイクルや範囲に限定して依存オブジェクトを管理する仕組みです。これにより、画面や処理単位で依存オブジェクトを再利用し、効率的にリソースを管理することができます。

スコープの基本概念


スコープを使用すると、次のような範囲で依存関係を管理できます：

  • 画面単位のスコープ：ActivityやFragmentごとに依存オブジェクトを保持します。
  • セッション単位のスコープ：特定のセッション中だけ依存関係を維持します。
  • タスク単位のスコープ：特定のタスクや処理が完了するまで依存関係を保持します。

スコープを適切に設定することで、不要なインスタンスの生成を防ぎ、メモリ効率を向上させることが可能です。

Koinスコープの利点

  1. リソース管理の最適化
    不必要なインスタンスの生成を避け、必要な範囲内でのみ依存関係を保持します。
  2. ライフサイクルの明確化
    依存関係のライフサイクルが明確になるため、メモリリークを防止できます。
  3. 効率的なメモリ使用
    画面や処理が終了するとスコープが破棄され、関連するオブジェクトも解放されます。

スコープの基本構文


Koinでスコープを作成する基本構文は次の通りです：

val myModule = module {
    scope<MyActivity> {
        scoped { MyScopedRepository() }
    }
}
  • scope<MyActivity>：MyActivityのライフサイクルに紐づいたスコープを定義します。
  • scoped { ... }：スコープ内で管理する依存オブジェクトを定義します。

スコープを使用する場面


Koinのスコープは、次のようなシーンで有効です：

  • Activityごとに異なる状態を管理する場合
  • 一時的なデータやセッション情報を保持する場合
  • 処理の一貫性を保つ必要がある複数の依存関係がある場合

Koinのスコープ機能を活用することで、効率的に依存関係を管理し、アプリケーションのパフォーマンスと可読性を向上させることができます。

Koinスコープの基本的な使い方


Koinにおけるスコープの設定方法を、具体的なステップを通して説明します。スコープを設定することで、特定のライフサイクルや処理範囲内で依存オブジェクトを再利用できます。

1. スコープの作成


まず、Koinモジュール内でスコープを定義します。以下は、MyActivityにスコープを設定し、MyScopedRepositoryをスコープ内で管理する例です。

val myModule = module {
    scope<MyActivity> {
        scoped { MyScopedRepository() }
    }
}
  • scope<MyActivity>：MyActivityのライフサイクルに紐づいたスコープを作成します。
  • scoped { MyScopedRepository() }：スコープ内で依存オブジェクトを管理します。

2. スコープの取得


Activity内でスコープを取得し、依存オブジェクトを注入します。以下はMyActivity内でスコープを使用する例です。

class MyActivity : AppCompatActivity() {
    // スコープ内の依存を注入
    private val myRepository: MyScopedRepository by injectScope()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // スコープの開始
        val scope = getOrCreateScope("myActivityScope", MyActivity::class)
        scope.inject()
    }

    override fun onDestroy() {
        // スコープの破棄
        getKoin().deleteScope("myActivityScope")
        super.onDestroy()
    }
}

3. 複数のスコープを管理


複数のスコープを作成して、異なるライフサイクルや処理単位で依存を管理することもできます。

val myModule = module {
    scope<MyActivity> {
        scoped { MyScopedRepository() }
    }
    scope<MyFragment> {
        scoped { MyFragmentService() }
    }
}

4. スコープの自動管理


Koinには、Androidライフサイクルに応じたスコープの自動管理機能もあります。activityScope()やfragmentScope()を利用して、ライフサイクルに合わせて自動でスコープを生成・破棄できます。

class MyActivity : AppCompatActivity(), KoinScopeComponent {
    override val scope: Scope by activityScope()

    private val myRepository: MyScopedRepository by inject()
}

5. スコープの破棄


スコープが不要になったら、破棄してリソースを解放します。

getKoin().deleteScope("myActivityScope")

まとめ


Koinでスコープを設定することで、ActivityやFragmentごとの依存関係を効率的に管理できます。スコープを適切に活用することで、メモリ管理が向上し、アプリケーションのパフォーマンスが最適化されます。

スコープのライフサイクル管理


Koinにおけるスコープのライフサイクル管理は、依存オブジェクトを効率的に管理し、適切なタイミングで生成・破棄するために重要です。これにより、メモリの無駄遣いを防ぎ、パフォーマンスを最適化できます。

スコープのライフサイクルの基本


Koinでスコープを利用する際、主に以下のライフサイクルに関連付けて管理します：

  1. Activityのライフサイクル
    Activityが作成されるとスコープが開始され、Activityが破棄されるとスコープも破棄されます。
  2. Fragmentのライフサイクル
    Fragmentごとにスコープを設定し、Fragmentが表示されている間のみ依存オブジェクトを保持します。
  3. カスタムライフサイクル
    任意のタイミングでスコープを作成し、特定のタスクや処理に関連付けることが可能です。

スコープの生成と破棄

1. スコープの生成

Koinでスコープを生成するには、getOrCreateScopeメソッドを使用します。

val scope = getOrCreateScope("myActivityScope", MyActivity::class)

2. スコープの破棄

不要になったスコープは、deleteScopeメソッドで破棄します。

getKoin().deleteScope("myActivityScope")

ライフサイクルに基づくスコープ管理の例

以下は、Activityのライフサイクルに合わせてスコープを管理する例です。

class MyActivity : AppCompatActivity() {
    private lateinit var scope: Scope

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // スコープを生成
        scope = getOrCreateScope("myActivityScope", MyActivity::class)
    }

    override fun onDestroy() {
        super.onDestroy()
        // スコープを破棄
        getKoin().deleteScope("myActivityScope")
    }
}

自動ライフサイクル管理

KoinはAndroidのライフサイクルに対応する自動スコープ管理もサポートしています。activityScope()やfragmentScope()を使用すると、スコープの生成と破棄を自動化できます。

class MyActivity : AppCompatActivity(), KoinScopeComponent {
    override val scope: Scope by activityScope()
    private val myRepository: MyScopedRepository by inject()
}

スコープ破棄時の注意点

  • メモリリークの防止：スコープを破棄しないと、依存オブジェクトがメモリに残り続ける可能性があります。ActivityやFragmentが破棄されるタイミングでスコープも確実に破棄しましょう。
  • 依存の再利用：スコープ内で再利用する依存オブジェクトが必要な場合は、スコープのライフサイクルを慎重に設計することが重要です。

まとめ


Koinのスコープのライフサイクル管理を活用することで、依存オブジェクトの生成・破棄を適切に行い、アプリのメモリ管理とパフォーマンスを向上させることができます。スコープの生成・破棄をライフサイクルに合わせて適切に実装しましょう。

実際のコード例：Koinでのスコープ実装


ここでは、Koinを使用してスコープを実装する具体的なコード例を示します。ActivityとFragmentでのスコープの設定方法、および依存関係の注入について解説します。

1. モジュールの作成


まず、Koinモジュール内でスコープと依存関係を定義します。

val appModule = module {
    // シングルトンで依存関係を定義
    single { Repository() }

    // MyActivity用のスコープ
    scope<MyActivity> {
        scoped { MyScopedService(get()) }
    }
}
  • single { Repository() }：アプリ全体でシングルトンとして利用するRepository。
  • scope<MyActivity>：MyActivityに紐づくスコープを作成。
  • scoped { MyScopedService(get()) }：スコープ内で管理される依存オブジェクト。

2. Activityでスコープを利用する


Activityでスコープを作成し、依存オブジェクトを注入します。

class MyActivity : AppCompatActivity() {
    // スコープ内の依存を注入
    private val myScopedService: MyScopedService by inject()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // スコープの開始
        val scope = getOrCreateScope("myActivityScope", MyActivity::class)
        scope.inject()

        myScopedService.performAction()
    }

    override fun onDestroy() {
        super.onDestroy()
        // スコープの破棄
        getKoin().deleteScope("myActivityScope")
    }
}

3. スコープ内で利用するクラス


スコープで管理するMyScopedServiceの定義です。

class MyScopedService(private val repository: Repository) {
    fun performAction() {
        println("Scoped Service is using Repository: ${repository.getData()}")
    }
}

class Repository {
    fun getData(): String = "Data from Repository"
}

4. Fragmentでスコープを利用する


Fragmentでも同様にスコープを設定して依存関係を管理できます。

class MyFragment : Fragment() {
    // Fragmentスコープの依存を注入
    private val myScopedService: MyScopedService by inject()

    override fun onCreateView(
        inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?
    ): View? {
        val scope = getOrCreateScope("myFragmentScope", MyFragment::class)
        scope.inject()

        myScopedService.performAction()

        return inflater.inflate(R.layout.fragment_main, container, false)
    }

    override fun onDestroyView() {
        super.onDestroyView()
        getKoin().deleteScope("myFragmentScope")
    }
}

5. Koinの初期化


ApplicationクラスでKoinを初期化し、モジュールをロードします。

class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        startKoin {
            androidContext(this@MyApp)
            modules(appModule)
        }
    }
}

コード全体のまとめ

  1. モジュール定義でスコープと依存関係を設定。
  2. ActivityやFragmentでスコープを作成し、依存を注入。
  3. 必要に応じてスコープを破棄し、メモリ管理を最適化。

Koinのスコープ機能を使うことで、ライフサイクルに沿った依存オブジェクト管理が可能になり、効率的なアプリケーション開発が実現します。

スコープを活用したDIの応用例


Koinのスコープ機能を活用すると、さまざまなシーンで効率的に依存関係を管理できます。ここでは、実践的な応用例として、複数の画面間でのデータ共有や、セッション管理、ダイアログ用スコープなどを紹介します。

1. 複数の画面間でのデータ共有


特定のデータを複数の画面間で共有する場合、スコープを使ってデータ管理が可能です。以下は、MyActivityとMyFragment間でデータを共有する例です。

モジュール定義：

val sharedModule = module {
    scope<MyActivity> {
        scoped { SharedViewModel() }
    }
}

Activity内でスコープを作成：

class MyActivity : AppCompatActivity() {
    private val sharedViewModel: SharedViewModel by inject()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val scope = getOrCreateScope("myActivityScope", MyActivity::class)
        scope.inject()
    }
}

Fragment内で共有データを利用：

class MyFragment : Fragment() {
    private val sharedViewModel: SharedViewModel by inject()

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        sharedViewModel.loadData()
    }
}

2. セッション管理


ユーザー認証が必要な場合、ログインセッションをスコープで管理できます。セッションが終了した際にスコープを破棄することで、安全にリソースを解放します。

モジュール定義：

val sessionModule = module {
    scope<SessionManager> {
        scoped { UserRepository() }
    }
}

セッション管理クラス：

class SessionManager {
    private val scope = getOrCreateScope("sessionScope", SessionManager::class)

    fun startSession() {
        scope.inject()
    }

    fun endSession() {
        getKoin().deleteScope("sessionScope")
    }
}

3. ダイアログ用の一時的なスコープ


ダイアログ表示時のみ特定の依存オブジェクトを保持するスコープを作成することも可能です。

モジュール定義：

val dialogModule = module {
    scope<MyDialogFragment> {
        scoped { DialogPresenter() }
    }
}

ダイアログFragmentでスコープを利用：

class MyDialogFragment : DialogFragment() {
    private val presenter: DialogPresenter by inject()

    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
        val scope = getOrCreateScope("dialogScope", MyDialogFragment::class)
        scope.inject()

        return AlertDialog.Builder(requireContext())
            .setTitle("Sample Dialog")
            .setMessage(presenter.getMessage())
            .setPositiveButton("OK") { _, _ -> }
            .create()
    }

    override fun onDestroyView() {
        super.onDestroyView()
        getKoin().deleteScope("dialogScope")
    }
}

4. ワークフロー単位でのスコープ管理


複数の処理ステップを伴うワークフローでもスコープを使って依存関係を管理できます。

モジュール定義：

val workflowModule = module {
    scope<WorkflowManager> {
        scoped { StepHandler() }
    }
}

ワークフロー管理クラス：

class WorkflowManager {
    private val scope = getOrCreateScope("workflowScope", WorkflowManager::class)

    fun executeWorkflow() {
        val stepHandler: StepHandler = scope.get()
        stepHandler.processStep()
    }

    fun finishWorkflow() {
        getKoin().deleteScope("workflowScope")
    }
}

まとめ


Koinのスコープ機能を活用することで、特定のライフサイクルや処理範囲に限定して依存関係を管理できます。複数の画面間でのデータ共有、セッション管理、ダイアログ表示、ワークフロー管理など、さまざまな応用シーンで効率的なDIを実現しましょう。

Koinスコープでのよくあるエラーと対処法


Koinでスコープを使用する際、ライフサイクルや依存関係の設定に関連するエラーが発生することがあります。ここでは、よくあるエラーとその対処法について解説します。

1. スコープが見つからないエラー

エラーメッセージ例：

org.koin.core.error.NoScopeFoundException: No scope found for id 'myActivityScope'

原因：
スコープを取得しようとしたときに、指定したIDのスコープが存在しない場合に発生します。スコープを作成していない、または既に破棄されている可能性があります。

対処法：
スコープを取得する前に、スコープが存在するか確認し、必要に応じて作成します。

val scope = getOrCreateScope("myActivityScope", MyActivity::class)

2. 依存関係が解決できないエラー

エラーメッセージ例：

org.koin.core.error.NoBeanDefFoundException: No definition found for class: MyScopedService

原因：
モジュールで依存関係を定義していない、またはスコープ外で依存を取得しようとした場合に発生します。

対処法：

  • モジュールで依存関係を正しく定義しているか確認します。
  • スコープ内で定義した依存は、そのスコープ内でのみ取得可能です。
val myModule = module {
    scope<MyActivity> {
        scoped { MyScopedService() }
    }
}

3. スコープのライフサイクルが一致しないエラー

エラーメッセージ例：

org.koin.core.error.ScopeNotCreatedException: Scope 'myFragmentScope' has not been created

原因：
FragmentやActivityが作成される前にスコープを使用しようとした場合に発生します。

対処法：
スコープを利用する前に必ずスコープを作成し、ライフサイクルに合わせて適切なタイミングで取得します。

class MyFragment : Fragment() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val scope = getOrCreateScope("myFragmentScope", MyFragment::class)
        scope.inject()
    }
}

4. スコープ破棄後の依存取得エラー

エラーメッセージ例：

org.koin.core.error.ScopeClosedException: Scope 'myActivityScope' is already closed

原因：
スコープを破棄した後に依存を取得しようとした場合に発生します。

対処法：
スコープが破棄されていないことを確認し、必要な処理が完了するまで破棄しないようにします。

override fun onDestroy() {
    super.onDestroy()
    getKoin().deleteScope("myActivityScope")
}

5. 複数のスコープIDの競合

エラーメッセージ例：

org.koin.core.error.ScopeAlreadyCreatedException: Scope with id 'myScope' already exists

原因：
同じIDで複数のスコープを作成しようとした場合に発生します。

対処法：
スコープIDが重複しないようにユニークなIDを設定するか、既存のスコープを再利用します。

val scope = getOrCreateScope("uniqueScopeId", MyActivity::class)

まとめ


Koinのスコープに関連するエラーは、主にライフサイクル管理や依存関係の定義ミスが原因です。エラーが発生した場合は、以下の点を確認しましょう：

  1. スコープの作成と取得が適切なタイミングで行われているか。
  2. 依存関係が正しくモジュールに定義されているか。
  3. スコープIDの重複がないか。
  4. スコープの破棄が適切に行われているか。

これらを意識することで、スムーズにKoinのスコープ機能を活用できます。

まとめ


本記事では、Kotlinにおける依存性注入（DI）ライブラリ「Koin」のスコープ機能について解説しました。Koinのスコープを活用することで、依存オブジェクトのライフサイクルを効率的に管理し、メモリの無駄を防ぎ、コードの保守性とパフォーマンスを向上させることができます。

導入から基本的なスコープの使い方、ライフサイクル管理、実際のコード例、さらにはよくあるエラーとその対処法まで詳しく解説しました。スコープを適切に設定すれば、ActivityやFragment単位で依存を管理したり、セッションやワークフローに応じた柔軟な管理が可能です。

Koinのスコープ機能をマスターし、効率的でメンテナンスしやすいKotlinアプリケーション開発を実現しましょう。

Kotlin
スコープ管理 DI Kotlin Koin

コメント

コメントする

目次
  1. 依存性注入（DI）とは
    1. DIの基本概念
    2. KotlinにおけるDIのメリット
    3. DIライブラリの必要性
  2. Koinの概要と特徴
    1. Koinの基本的な特徴
    2. Koinの仕組み
    3. Koinと他のDIライブラリとの比較
  3. Koinにおけるスコープとは
    1. スコープの基本概念
    2. Koinスコープの利点
    3. スコープの基本構文
    4. スコープを使用する場面
  4. Koinスコープの基本的な使い方
    1. 1. スコープの作成
    2. 2. スコープの取得
    3. 3. 複数のスコープを管理
    4. 4. スコープの自動管理
    5. 5. スコープの破棄
    6. まとめ
  5. スコープのライフサイクル管理
    1. スコープのライフサイクルの基本
    2. スコープの生成と破棄
    3. ライフサイクルに基づくスコープ管理の例
    4. 自動ライフサイクル管理
    5. スコープ破棄時の注意点
    6. まとめ
  6. 実際のコード例：Koinでのスコープ実装
    1. 1. モジュールの作成
    2. 2. Activityでスコープを利用する
    3. 3. スコープ内で利用するクラス
    4. 4. Fragmentでスコープを利用する
    5. 5. Koinの初期化
    6. コード全体のまとめ
  7. スコープを活用したDIの応用例
    1. 1. 複数の画面間でのデータ共有
    2. 2. セッション管理
    3. 3. ダイアログ用の一時的なスコープ
    4. 4. ワークフロー単位でのスコープ管理
    5. まとめ
  8. Koinスコープでのよくあるエラーと対処法
    1. 1. スコープが見つからないエラー
    2. 2. 依存関係が解決できないエラー
    3. 3. スコープのライフサイクルが一致しないエラー
    4. 4. スコープ破棄後の依存取得エラー
    5. 5. 複数のスコープIDの競合
    6. まとめ
  9. まとめ