【和訳】Using Dagger in your Android app(Codelabs for the 2019 Android Dev Summit: Mountain View, October 23-24, 2019.)

[Android Dev Summit 2019
Codelabs for the 2019 Android Dev Summit: Mountain View, October 23-24, 2019.](https://codelabs.developers.google.com/ads19/)

[Using Dagger in your Android app](https://codelabs.developers.google.com/codelabs/android-dagger/index.html?index=..%2F..ads19)の日本語訳

# 1.はじめに
このコードラボでは、Dependency Injection（DI）の重要性を学習し、大規模プロジェクトに対応する堅実で拡張可能なアプリケーションを作成します。Daggerは依存関係を管理するDIツールとして使用します。
依存性注入（DI）は、プログラミングで広く使用されている手法であり、Android開発に適しています。 DIの原則に従うことで、優れたアプリアーキテクチャの基礎を築きます。
依存性注入を実装すると、次の利点が得られます。

- コードの再利用性
- リファクタリングの容易さ
- テストのしやすさ

## 前提条件
- Kotlin構文の経験
- 依存性注入とAndroidアプリでDaggerを使用する利点を理解していること

> 依存性注入の詳細と、AndroidアプリでDaggerがどのように役立つかについては、こちらをご覧ください。
> 1. [依存性注入の基礎](https://developer.android.com/training/dependency-injection)
> 2. [Androidでの依存関係注入のマニュアル](https://developer.android.com/training/dependency-injection/manual)
> 3. [AndroidアプリでDaggerを使用する利点](https://developer.android.com/training/dependency-injection/dagger-basics)
>

## 学ぶこと
- 大規模なAndroidアプリでDaggerを使用する方法
- より堅実で持続可能なアプリを作成するための関連するDaggerの概念
- Daggerサブコンポーネントが必要な理由とその使用方法
- Daggerを使用するアプリケーションでユニットテストとインストゥルメント化テストする方法

コードラボの終わりまでに、あなたはこのようなアプリケーションのグラフを作成し、テストしています
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/170755/02927115-63a8-83ef-78bb-5de741bbc3c8.png)
矢印はオブジェクト間の依存関係を表します。 これをアプリケーショングラフと呼びます。アプリのすべてのクラスとそれらの間の依存関係です。
読み続けて、その方法を学びましょう！

# 2.設定する
## コードを入手する
GitHubからcodelabのコードを取得します。

```
$ git clone https://github.com/googlecodelabs/android-dagger
```

また、リポジトリをZipファイルとしてダウンロードできます。
[ダウンロード](https://github.com/googlecodelabs/android-dagger/archive/master.zip)

## Android Studioを開きます
Android Studioをダウンロードする必要がある場合は、[ここ](https://developer.android.com/studio/)からダウンロードできます。
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/170755/3e0678fd-ed76-58d5-db2b-e8a43e86c84b.png)

## プロジェクトのセットアップ
このプロジェクトは、複数のGitHubブランチで構築されています。

- masterは、チェックアウトまたはダウンロードしたブランチです。 コードラボの出発点。
- 1_registration_main、2_subcomponents、および3_dagger_appは、ソリューションへの中間ステップです。
- ソリューションには、このコードラボのソリューションが含まれています。

masterブランチから始めて、自分のペースでステップごとにコードラボに従うことをお勧めします。
コードラボでは、プロジェクトに追加する必要があるコードのスニペットが表示されます。一部の場所では、明示的に記述されているコードやコードスニペットのコメントに含まれるコードも削除する必要があります。
チェックポイントとして、特定のステップで支援が必要な場合に利用できる中間ブランチがあります。
gitを使用してソリューションブランチを取得するには、次のコマンドを使用します。

```
$ git clone -b solution https://github.com/googlecodelabs/android-dagger
```

または、ここからソリューションコードをダウンロードできます。
[ダウンロード](https://github.com/googlecodelabs/android-dagger/archive/solution.zip)

## よくある質問

- Android Studioをインストールするにはどうすればよいですか？
- 開発用のデバイスを設定するにはどうすればよいですか？

# 3.サンプルアプリの実行
最初に、開始サンプルアプリの外観を見てみましょう。 以下の手順に従って、Android Studioでサンプルアプリを開きます。

- zipアーカイブをダウンロードした場合は、ファイルをローカルで解凍します
- Android Studioでプロジェクトを開きます
- ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/170755/ce56eb5f-af58-2f99-790f-98d4402822ac.png)
実行ボタンをクリックし、エミュレーターを選択するか、Androidデバイスを接続します。 登録画面が表示されます

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/170755/02602e32-a4c5-6737-69ed-f1aa51098c78.png)

アプリは4つの異なるフローで構成されます（アクティビティとして実装）
- **登録**：ユーザーは、ユーザー名、パスワードを紹介し、利用規約に同意することで登録できます
- **ログイン**：ユーザーは、登録フロー中に導入された資格情報を使用してログインでき、アプリから登録解除することもできます
- **ホーム**：ユーザーは歓迎され、未読通知の数を確認できます
- **設定**：ユーザーはログアウトして未読の通知の数を更新できます（ランダムな数の通知が生成されます）

このプロジェクトは、Viewのすべての複雑さがViewModelに委ねられる典型的なMVVMパターンに従います。 時間をかけてプロジェクトの構造を理解してください。
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/170755/71b16e9f-5d3a-b347-f21a-ebb1a0e5156a.png)

矢印はオブジェクト間の依存関係を表します。 これをアプリケーショングラフと呼びます。アプリのすべてのクラスとそれらの間の依存関係です。
masterブランチのコードは、依存関係を手動で管理します。 手作業で作成する代わりに、Daggerを使用して管理するためにアプリをリファクタリングします。

## 免責事項
このコードラボは、アプリの設計方法については述べていません。Daggerをアプリアーキテクチャにプラグインできるさまざまな方法を紹介することを目的としています。複数のフラグメントを持つ単一のアクティビティ（登録およびログインフロー）または複数のアクティビティ（メインアプリフロー）。
コードラボを完了してDaggerの主な概念を理解し、それに応じてプロジェクトに適用できます。 このコードラボで使用されている一部のパターンは、Androidアプリケーションを構築するための推奨される方法ではありませんが、Daggerを説明するのに最適なパターンです。
Androidアプリアーキテクチャの詳細については、[アプリアーキテクチャガイドページ](https://developer.android.com/jetpack/docs/guide)をご覧ください。

## なぜDaggerなのか？
アプリケーションが大きくなると、エラーが発生する可能性のあるボイラープレートコード（ファクトリーなど）の記述を開始します。 これを間違えると、アプリで微妙なバグやメモリリークが発生する可能性があります。
コードラボでは、Daggerを使用してこのプロセスを自動化し、他の方法で手書きで記述したのと同じコードを生成する方法を説明します。
Daggerがアプリケーショングラフの作成を担当します。 また、依存関係を手動で作成する代わりに、アクティビティでフィールドインジェクションを実行するためにDaggerを使用します。
なぜDaggerなのかの詳細は[こちら](https://developer.android.com/training/dependency-injection/dagger-basics)。

# 4. Daggerをプロジェクトに追加する
Daggerをプロジェクトに追加するには、app/build.gradleファイルを開き、ファイルの上部に2つのDagger依存関係とkaptプラグインを追加します。

```app/build.gradle
apply plugin: 'com.android.application'
apply plugin: 'kotlin-android'
apply plugin: 'kotlin-android-extensions'
apply plugin: 'kotlin-kapt'

...

dependencies {
    ...
    def dagger_version = "2.25.2"
    implementation "com.google.dagger:dagger:$dagger_version"
    kapt "com.google.dagger:dagger-compiler:$dagger_version"
}
```

これらの行をファイルに追加したら、ファイルの上部に表示される[Sync Now]ボタンをクリックします。 これにより、プロジェクトが同期され、新しい依存関係がダウンロードされます。 これでアプリでDaggerを使用する準備が整いました。
Daggerは、Javaのアノテーションモデルを使用して実装されます。 アノテーションプロセッサを使用して、コンパイル時にコードを生成します。アノテーションプロセッサは、kaptコンパイラプラグインを使用してKotlinでサポートされています。これは、ファイル上部の[apply plugin: 'kotlin-android-extensions']行の下のに[apply plugin: 'kotlin-kapt']を追加することで有効になります。
依存関係では、daggerライブラリにはアプリで使用できるすべてのアノテーションが含まれており、dagger-compilerはコードを生成するアノテーションプロセッサです。後者はアプリに入っていません。
Daggerの利用可能な最新バージョンは、[こちら](https://github.com/google/dagger/releases)で見つけることができます。

# 5. @Injectアノテーション
Daggerを使用するために登録フローのリファクタリングを始めましょう。
アプリケーショングラフを自動的に作成するために、Daggerはグラフ内のクラスのインスタンスを作成する方法を知る必要があります。これを行う1つの方法は、クラスのコンストラクターに@Injectアノテーションを付けることです。コンストラクターのパラメーターは、そのタイプの依存関係になります。
RegistrationViewModel.ktファイルを開き、クラス定義を次のものに置き換えます。

```RegistrationViewModel.kt
// @Injectは、この型のインスタンスを提供する方法をDaggerに伝えます
// Daggerは、UserManagerが依存関係であることも知っています
class RegistrationViewModel @Inject constructor(val userManager: UserManager) {
    ...
}
```

Kotlinでは、コンストラクターにアノテーションを適用するには、上記のスニペットコードに示すように、キーワードコンストラクターを具体的に追加し、その直前にアノテーションを導入する必要があります。
@Injectアノテーションにより、Daggerは次のことを認識します。
1. RegistrationViewModel型のインスタンスを作成する方法。
2. コンストラクターは引数としてUserManagerのインスタンスを取るため、RegistrationViewModelには依存関係としてUserManagerがあります。

> 簡単にするために、RegistrationViewModelは[AndroidアーキテクチャコンポーネントのViewModel](https://developer.android.com/topic/libraries/architecture/viewmodel)ではありません。 ViewModelとして機能するのは単なる通常のクラスです。
> Daggerでこれを使用する方法の詳細については、公式の[Android Blueprints code](https://github.com/android/architecture-samples/tree/dagger-android)の実装をご覧ください。

DaggerはまだUserManagerを作成タイプの方法を知りません。 同じプロセスに従って、@InjectアノテーションをUserManagerのコンストラクターに追加します。
UserManager.ktファイルを開き、クラス定義を次のものに置き換えます。

```UserManager.kt
class UserManager @Inject constructor(private val storage: Storage) {
    ...
}
```

これで、DaggerはRegistrationViewModelおよびUserManagerのインスタンスを提供する方法を認識しました。
UserManagerの依存関係（つまり、ストレージ）はインターフェイスであるため、別の方法でそのインスタンスを作成する方法をDaggerに伝える必要があります。これについては後で説明します。

# ビューにはグラフのオブジェクトが必要です
アクティビティやフラグメントなどの特定のAndroidフレームワーククラスはシステムによってインスタンス化されるため、Daggerはそれらを作成できません。特にアクティビティの場合、初期化コードはonCreateメソッドに移動する必要があります。そのため、以前のようにViewクラスのコンストラクターで@Injectアノテーションを使用することはできません（コンストラクターインジェクションと呼ばれます）。代わりに、フィールドインジェクションを使用する必要があります。
手動の依存関係注入のように、アクティビティがonCreateメソッドで必要とする依存関係を作成する代わりに、Daggerにこれらの依存関係を設定してもらいます。フィールドインジェクション（アクティビティとフラグメントで一般的に使用される）の場合、Daggerに提供するフィールドに@Injectアノテーションを付けます。
このアプリでは、RegistrationActivityはRegistrationViewModelに依存しています。
RegistrationActivity.ktを開くと、supportFragmentManagerを呼び出す直前にonCreateメソッドでViewModelが作成されます。
手作業で作成するのではなく、Daggerが提供するようにします。 そのためには、次のことが必要です。

1. フィールドに@Injectアノテーションを付けます
2. onCreateメソッドからインスタンス化を削除します

```RegistrationActivity.kt
class RegistrationActivity : AppCompatActivity() {

    // @Inject annotated fields will be provided by Dagger
    @Inject
    lateinit var registrationViewModel: RegistrationViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        ...
        // Remove following line
        registrationViewModel = RegistrationViewModel((application as MyApplication).userManager)
    }
}
```

> クラスコンストラクターで@Injectアノテーションが付いている場合、そのクラスのインスタンスを提供する方法をDaggerに伝えています。クラスフィールドにアノテーションを付けると、そのタイプのインスタンスをフィールドに入力する必要があることをDaggerに伝えます。

どのオブジェクトをそのRegistrationActivityに注入する必要があるかをDaggerに伝えるにはどうすればよいですか？Daggerグラフ（またはアプリケーショングラフ）を作成し、それを使用してオブジェクトをアクティビティに注入する必要があります。

# 6. @Componentアノテーション
Daggerにプロジェクトの依存関係のグラフを作成し、管理してもらい、グラフから依存関係を取得できるようにします。Daggerで実行するには、インターフェイスを作成し、@Componentアノテーションを付ける必要があります。Daggerは、手動の依存関係注入で行ったように、コンテナを作成します。
@Componentは、Daggerが公開するメソッドのパラメーターを満たすために必要なすべての依存関係を持つコードを生成します。そのインターフェース内で、RegistrationActivityがインジェクションを要求していることをDaggerに伝えることができます。

```app/src/main/java/com/example/android/dagger/di/AppComponent.kt
package com.example.android.dagger.di

import com.example.android.dagger.registration.RegistrationActivity
import dagger.Component

// Daggerコンポーネントの定義
@Component
interface AppComponent {
    // このコンポーネントによって注入できるクラス
    fun inject(activity: RegistrationActivity)
}
```

@Componentインターフェースのinject(activity: RegistrationActivity)メソッドを使用して、RegistrationActivityがインジェクションを要求し、Activityがインジェクトするものを提供する必要があることをDaggerに伝えています（つまり、前のステップで定義したRegistrationViewModel）。
DaggerはRegistrationViewModelのインスタンスを内部で作成する必要があるため、RegistrationViewModelの依存関係（つまりUserManager）を満たす必要もあります。Daggerが提供する必要があるオブジェクトの依存関係を見つけるこの再帰プロセス中に、特定の依存関係を提供する方法がわからない場合、コンパイル時に、満たすことができない依存関係があると言って失敗します。

> @Componentインターフェイスは、Daggerがコンパイル時にグラフを生成するために必要な情報を提供します。インターフェイスメソッドのパラメーターは、どのクラスがインジェクションを要求するかを定義します。

アプリをビルドすると、依存関係を管理するために必要なコードを生成するDaggerの注釈プロセッサがトリガーされます。 Android Studioのビルドボタンを![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/170755/cc5f3ce3-7887-4785-fc3d-deac1d22b2d5.png)使用してそれを行うと、次のエラーが表示されます。

```
dagger/app/build/tmp/kapt3/stubs/debug/com/example/android/dagger/di/AppComponent.java:7: error: [Dagger/MissingBinding] com.example.android.dagger.storage.Storage cannot be provided without an @Provides-annotated method
```

分解してみましょう。まず、AppComponentでエラーが発生していることを示しています。エラーのタイプは[Dagger/MissingBinding]です。これは、Daggerが特定のタイプを提供する方法を知らないことを意味します。読み続けると、@Provides注釈付きメソッドがないとストレージを提供できないと言われます。
Storage型のオブジェクトを提供する方法をDaggerに伝えるのを忘れていました！

# 7. @Module、@Bindsおよび@BindsInstanceアノテーション
Storageはインターフェースであるため、Daggerにストレージを提供する方法を指定する方法は異なります。使用するストレージの実装をDaggerに伝える必要があります: SharedPreferencesStorage
型のインスタンスを提供する方法をDaggerに伝える別の方法は、Daggerモジュールの情報を使用します。ダガーモジュールは、@Moduleアノテーションが付けられたクラスです。そこで、@Providesまたは@Bindsアノテーションを使用して依存関係を提供する方法を定義できます。

> @Providesの詳細については、Androidアプリのドキュメントでダガーを使用するか、このコードラボの最後にあります。

このモジュールにはストレージに関する情報が含まれるので、AppComponent.ktを作成したのと同じパッケージにStorageModule.ktという別のファイルを作成しましょう。 そのファイルでは、@ Moduleアノテーションが付けられたStorageModuleというクラスを定義します。

```app/src/main/java/com/example/android/dagger/di/StorageModule.kt
package com.example.android.dagger.di

import dagger.Module

// ダガーモジュールであることをダガーに伝える
@Module
class StorageModule {

}
```

## @Bindsアノテーション
@Bindsを使用して、インターフェイスを提供するときに使用する必要のある実装をDaggerに伝えます。
@Bindsは抽象関数に注釈を付ける必要があります（抽象であるため、コードが含まれておらず、クラスも抽象である必要があるため）。抽象関数の戻り値の型は、実装（つまりストレージ）を提供するインターフェイスです。実装は、インターフェイス実装タイプ（つまり、SharedPreferencesStorage）を持つ一意のパラメーターを追加することによって指定されます。

```StorageModule.kt
// ダガーモジュールであることをダガーに伝える
// @Bindsのため、StorageModuleは抽象クラスである必要があります
@Module
abstract class StorageModule {

    // ストレージ型が要求されたときにDaggerがSharedPreferencesStorageを提供するようにします
    @Binds
    abstract fun provideStorage(storage: SharedPreferencesStorage): Storage
}
```

上記のコードを使用して、StorageインターフェイスをSharedPreferencesStorageの実装にリンクしました。現在StorageModuleは抽象的であることに注意してください。

> モジュールは、セマンティックな方法でオブジェクトの提供の仕方をカプセル化する方法です。ご覧のとおり、ストレージモジュールを呼び出して、ストレージに関連するオブジェクトを提供するロジックをグループ化しました。ここでアプリケーションが拡張または複雑になった場合、たとえば、SharedPreferencesのさまざまな実装を提供する方法もここに含めることができます。

DaggerはSharedPreferencesStorageのインスタンスを作成する方法をまだ知りません。 以前と同じように、SharedPreferencesStorageのコンストラクターに@Injectアノテーションを付けます。

```SharedPreferencesStorage.kt
// @Injectは、この型のインスタンスを提供する方法をDaggerに伝えます
class SharedPreferencesStorage @Inject constructor(context: Context) : Storage { ... }
```

アプリケーショングラフは、StorageModuleについて知る必要があります。 そのため、次のようにAppComponentの@Componentアノテーション内にmodulesパラメーターを含めます。

```AppComponent.kt
// StorageModuleからの情報をグラフに追加するDaggerコンポーネントの定義
@Component(modules = [StorageModule::class])
interface AppComponent {
    
    // このコンポーネントによって注入できるクラス
    fun inject(activity: RegistrationActivity)
}
```

このようにして、AppComponentはStorageModuleに含まれる情報にアクセスできます。より複雑なアプリケーションでは、OkHttpClientを提供する方法や、GsonやMoshiを構成する方法などの情報を追加するNetworkModuleを使用することもできます。
再度ビルドしようとすると、前と同じようなエラーが表示されます！ 今回Daggerが見つけられないのは、コンテキストです。

# @BindsInstanceアノテーション
Daggerに*Context*の提供方法を伝えるにはどうすればよいですか？*Context*はAndroidシステムによって提供されるため、グラフの外部で構築されます。*Context*はグラフのインスタンスを作成する時点ですでに利用可能であるため、渡すことができます。
渡す方法は、コンポーネントファクトリを使用し、*@BindsInstance*アノテーションを使用することです。

```AppComponent.kt
@Component(modules = [StorageModule::class])
interface AppComponent {

    // AppComponentのインスタンスを作成するファクトリー
    @Component.Factory
    interface Factory {
        // @BindsInstanceを使用すると、渡されたコンテキストはグラフで利用可能になります
        fun create(@BindsInstance context: Context): AppComponent
    }

    fun inject(activity: RegistrationActivity)
}
```

*@Component.Factory*アノテーションが付けられた*Factory*というインターフェースを宣言しています。内部には、コンポーネント型（つまり、AppComponent）を返すメソッドがあり、*@BindsInstance*アノテーションが付けられた*Context*型のパラメーターがあります。
*@BindsInstance*はDaggerに、そのインスタンスをグラフに追加する必要があること、およびコンテキストが必要な場合は常にそのインスタンスを提供することを伝えます。

> *@BindsInstance*は、グラフの外部で構築されたオブジェクト（*Context*のインスタンスなど）に使用します。

## プロジェクトは正常にビルドされます
ここでプロジェクトをビルドすると、すべてが緑色でエラーが表示されないことがわかります。これは、Daggerがグラフを正常に生成し、すぐに使用する準備ができたことを意味します。
アプリケーショングラフの実装は、アノテーションプロセッサによって自動的に生成されます。生成されたクラスは*Dagger{ComponentName}*と呼ばれ、グラフの実装が含まれます。次のセクションでは、生成された*DaggerAppComponent*クラスを使用します。
*AppComponent*グラフはどのようになりましたか？
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/170755/d3c7b75e-51e2-c00c-0ad7-27dd9054f52f.png)
*AppComponent*には、*Storage*インスタンスを提供する方法に関する情報を含む*StorageModule*が含まれています。*Storage*は*Context*に依存していますが、グラフを作成するときに*Storage*を提供しているため、*Storage*はすべての依存関係をカバーしています。
*Context*のインスタンスは、*AppComponent*ファクトリの*create*メソッドに渡されます。したがって、オブジェクトが"Context"を必要とするときはいつでも同じインスタンスが提供されます。これは、ダイアグラムの白い点で表されています。
これで、*RegistrationActivity*はグラフにアクセスして、Dagger（この場合は*RegistrationViewModel*）によって挿入（または入力）されたオブジェクトを取得できます。
*AppComponent*は、*RegistrationViewModel*のインスタンスを作成できるように、*RegistrationActivity*の*RegistrationViewModel*を設定する必要があるため、依存関係（つまり、*UserManager*）を満たし、*UserManager*のインスタンスも作成する必要があります。*UserManager*には*@Inject*アノテーションが付けられたコンストラクターがあるため、Daggerはそれを使用してインスタンスを作成します。*UserManager*は*Storage*に依存していますが、すでにグラフにあるため、他に何も必要ありません。

# 8.アクティビティへのグラフの挿入
Androidでは、アプリが実行されている限りグラフのインスタンスをメモリに保持するため、通常はApplicationクラスに存在するDaggerグラフを作成します。このようにして、グラフはアプリのライフサイクルに付属されます。この場合、グラフでアプリケーションのコンテキストを使用できるようにすることも必要です。利点として、グラフは他のAndroidフレームワーククラスで利用可能です（*Context*でアクセスできます）また、テストでカスタムApplicationクラスを使用できるため、テストにも適しています。

グラフのインスタンス（つまり*AppComponent*）をカスタムアプリケーション*MyApplication*に追加しましょう。

```MyApplication.kt
open class MyApplication : Application() {

    // プロジェクト内のすべてのアクティビティで使用されるAppComponentのインスタンス
    val appComponent: AppComponent by lazy {
        // Factoryコンストラクターを使用してAppComponentのインスタンスを作成します
        // グラフのコンテキストとして使用されるapplicationContextを渡します
        DaggerAppComponent.factory().create(applicationContext)
    }

    open val userManager by lazy {
        UserManager(SharedPreferencesStorage(this))
    }
}
```

前のセクションで述べたように、Daggerは、プロジェクトをビルドしたときに*AppComponent*グラフの実装を含む*DaggerAppComponent*というクラスを生成しました。*@Component.Factory*アノテーションでコンポーネントファクトリを定義したため、*DaggerAppComponent*の静的メソッドである*.factory()*を呼び出すことができます。これで、*Context*（この場合は*applicationContext*）を渡すファクトリ内で定義した*create*メソッドを呼び出すことができます。
変数が不変であり、必要な場合にのみ初期化されるように、[Kotlin lazy initialization](https://kotlinlang.org/docs/reference/delegated-properties.html#lazy)を使用してこれを行います。

> **注**：*DaggerAppComponent*がプロジェクトに存在しないというエラーが表示された場合。 Daggerアノテーションプロセッサがコードを生成できるようにプロジェクトをビルドする必要があります。
> 新しいDaggerコードを有効にするには、常にプロジェクトをビルドする必要があります。

*RegistrationActivity*のグラフの*this*インスタンスを使用して、Daggerに*@Inject*アノテーションが付けられたフィールドを挿入させることができます。どうすればできますか？*RegistrationActivity*をパラメーターとして使用する*AppComponent*のメソッドを呼び出す必要があります。

```RegistrationActivity.kt
class RegistrationActivity : AppCompatActivity() {

    // @Inject annotated fields will be provided by Dagger
    @Inject
    lateinit var registrationViewModel: RegistrationViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        // アプリケーショングラフのインスタンスを取得します
        // @Injectフィールドにグラフのオブジェクトを入力します
        (application as MyApplication).appComponent.inject(this)

        super.onCreate(savedInstanceState)
        ...
    }

    ...
}
```

*appComponent.inject(this)*を呼び出すと、*RegistrationActivity*が*@Inject*（つまりregistrationViewModel）でアノテーションを付けたフィールドにデータが入力されます。

> **重要**：アクティビティを使用する場合は、フラグメントの復元に関する問題を回避するために、アクティビティの*onCreate*メソッドで*super.onCreate*を呼び出す前にDaggerを注入します。*super.onCreate*で、復元フェーズ中のアクティビティは、アクティビティバインディングにアクセスしたいフラグメントをアタッチします。

RegistrationActivityはすでにDaggerを使用して依存関係を管理しています！ 先に進み、アプリを実行できます。

バグを見つけましたか？登録フローの後にメインページが表示されます！しかし、そうではない。ログインでもそうです。
どうしてですか？アプリの他のフローでは、Daggerグラフをまだ使用していません。
メインフローでもDaggerを使用して、この問題を修正しましょう。

## メインフローでのDaggerの使用
前回と同様に、*MainActivity*でDaggerを使用して依存関係を管理する必要があります。 この場合、*MainViewModel*および*UserManager*です。
*MainActivity*がインジェクションを要求していることをDaggerに伝えるには、*AppComponent*のインターフェイスのパラメーターとして*MainActivity*を含む別の関数を追加する必要があります。

```AppComponent.kt
@Component(modules = [StorageModule::class])
interface AppComponent {
    ...

    // *this*コンポーネントによって注入できるクラス
    fun inject(activity: RegistrationActivity)
    fun inject(activity: MainActivity)
}
```

関数の名前は重要ではありません（そのため、両方の関数を*inject*と呼んでいます）。重要なのはパラメーターの型です。*MainActivity*でDaggerから注入するものを定義し、グラフを注入しましょう。

1.*userManager*と*mainViewMode*lの両方のフィールドに*@Inject*でアノテーションを付けます。

```MainActivity.kt
class MainActivity : AppCompatActivity() {

    // *@Inject*アノテーション付きフィールドはDaggerによって提供されます
    @Inject
    private lateinit var userManager: UserManager

    @Inject
    private lateinit var mainViewModel: MainViewModel

    ...
}
```

2.Daggerによって行われるため、*userManager*および*mainViewModel*の初期化を削除します。

```MainActivity.kt
class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        ...

        // ここを削除
        userManager = (application as MyApplication).userManager
        if (!userManager.isUserLoggedIn()) {
           ...
        } else {
           ...
           // ここも削除
            mainViewModel = MainViewModel(userManager.userDataRepository!!)
           ...
        }
    }
    ...
}
```

3.*appComponent*に*MainActivity*を挿入して、挿入されたフィールドに入力します。

```MainActivity.kt
class MainActivity : AppCompatActivity() {
    ...
    override fun onCreate(savedInstanceState: Bundle?) {

        (application as MyApplication).appComponent.inject(this)

        super.onCreate(savedInstanceState)
        ...
    }
}
```

*UserManager*はすでにグラフで利用できるため、Daggerは提供方法を知っていますが、*MainViewModel*は利用できません。*@Inject*アノテーションをコンストラクターに追加して、Daggerがクラスのインスタンスの作成方法を認識できるようにします。

```MainViewModel.kt
class MainViewModel @Inject constructor(private val userDataRepository: UserDataRepository) { ... }
```

*MainViewModel*は*UserDataRepository*に依存しているため、*@Inject*のアノテーションを付ける必要があります。

```UserDataRepository.kt
class UserDataRepository @Inject constructor(private val userManager: UserManager) { ... }
```

*UserManager*はすでにグラフの一部であるため、Daggerはグラフを正常に作成するために必要なすべての情報を持っています。
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/170755/fbd5e67d-a245-1777-ebf0-dd5e85892b7d.png)
この時点でのアプリケーショングラフの現在の状態

プロジェクトを再度ビルドしようとすると、別のエラーが発生するはずです。
それは何と言っていますか？**エラー**：Daggerはプライベートフィールドへの挿入をサポートしていません。 これはDaggerの欠点の1つです。挿入されたフィールドには、少なくともパッケージプライベート以上の可視性が必要です。それらはクラスのプライベートにすることはできません。
フィールド定義から*private*修飾子を削除します。

```MainActivity.kt
class MainActivity : AppCompatActivity() {

    @Inject
    lateinit var userManager: UserManager

    @Inject
    lateinit var mainViewModel: MainViewModel

    ...
}
```

> **重要**：Dagger注入フィールドはプライベートにすることはできません。 少なくともパッケージプライベートの可視性が必要です。

これで、プロジェクトを正常にビルドできます。アプリを再度実行してみましょう。再度実行すると、以前にユーザーを登録したため、ログイン画面が表示されます。初めてアプリケーションを実行したときに新たに開始するには、「登録解除」をクリックして登録フローに移動します。

登録すると、メインページには移動しません！ログインアクティビティに再び行きます。 バグが再び発生していますが、なぜですか？メインフローと登録フローの両方が、アプリケーショングラフから*UserManager*を挿入しています。
問題は、デフォルトで依存関係を注入するときに、Daggerが常に型の新しいインスタンスを提供することです。毎回同じインスタンスを再利用するようにDaggerを作成するにはどうすればよいですか？スコープ付きにすることです。

# 9.スコープの使用
場合によっては、複数の理由により、コンポーネントの依存関係の同じインスタンスを提供することがあります。
1. 依存関係としてこのタイプを持つ他のタイプが同じインスタンスを共有するようにします（例では*UserManager*）。
2. オブジェクトの作成は非常に高価であり、依存関係（Jsonパーサーなど）として宣言されるたびに新しいインスタンスを作成する必要はありません。

スコープを使用して、コンポーネント内の型の一意のインスタンスを保持します。これは、「コンポーネントのライフサイクルに型をスコープする」とも呼ばれます。コンポーネントに型をスコープするということは、型を提供する必要があるたびに、その型の同じインスタンスが使用されることを意味します。
*AppComponent*には、*javax.inject*パッケージに付属する唯一のスコープアノテーションである*@Singleton*スコープアノテーションを使用できます。*@Singleton*を使用してコンポーネントにアノテーションを付けると、アノテーションが付けられたすべてのクラスは、アノテーションが付けられたコンポーネントにスコープされます。
*AppComponent.kt*ファイルを開き、コンポーネントに*@Singleton*のアノテーショ」ンを付けます。

```AppComponent.kt
@Singleton
@Component(modules = [StorageModule::class])
interface AppComponent { ... }
```

これで、*@Singleton*アノテーションが付けられたクラスのスコープが*AppComponent*になります。*UserManager*にアノテーショ」ンを付けて、アプリケーショングラフに一意のインスタンスを持たせましょう。

```UserManager.kt
@Singleton
class UserManager @Inject constructor(private val storage: Storage) {
    ...
}
```

これで、*UserManager*の同じインスタンスが*RegistrationActivity*と*MainActivity*に提供されます。
アプリを再度実行し、登録フローに移動して、以前と同様に新たに開始します。 これで、登録が完了すると、メインフローに移動します！ 問題が解決しました。

> この時点でのコードラボのソリューションは、Githubプロジェクトの*1_registration_main*ブランチにあります。

興味がある場合は、アプリケーショングラフがどのように見えるかです。
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/170755/2f85bfe7-c528-41f3-cc8d-7359c6db21a5.png)
*AppComponent*の*UserManager*の一意のインスタンスを持つグラフの現在の状態
*UserManager*にも白い点が付いていることに注意してください。*Context*で発生したように、*AppComponent*の同じインスタンスの依存関係として必要な場合、その*UserManager*の同じインスタンスが常に提供されます。

# 10.サブコンポーネント
## 登録フロー
アプリをDaggerにリファクタリングし続けましょう。登録フラグメントはまだ手動の依存性注入を使用しています。それらを今すぐ移行しましょう。
両方のフラグメントをDaggerによって注入する必要があるため、*AppComponent*インターフェイスに追加してDaggerに知らせる必要があります。

```AppComponent.kt
@Singleton
@Component(modules = [StorageModule::class])
interface AppComponent {
    ...
    fun inject(activity: RegistrationActivity)
    fun inject(fragment: EnterDetailsFragment)
    fun inject(fragment: TermsAndConditionsFragment)
    fun inject(activity: MainActivity)
}
```

Daggerに提供するフィールドはどれですか？+EnterDetailsFragment*では、Daggerに両方の*ViewModel*を設定します。それには、フィールドに*@Inject*アノテーションを付け、プライベートの可視性修飾子を削除します。

```EnterDetailsFragment.kt
class EnterDetailsFragment : Fragment() {

    @Inject
    lateinit var registrationViewModel: RegistrationViewModel
    
    @Inject
    lateinit var enterDetailsViewModel: EnterDetailsViewModel

    ...
}
```

But we also have to remove the manual instantiations we have in the code. Remove the following lines:

```EnterDetailsFragment.kt
class EnterDetailsFragment : Fragment() {

    override fun onCreateView(...): View? {
        ...
        // 次の行を削除
        registrationViewModel = (activity as RegistrationActivity).registrationViewModel
        enterDetailsViewModel = EnterDetailsViewModel()

        ...
    }
}
```

これで、Applicationクラスの*appComponent*インスタンスを使用して、フラグメントを注入できます。フラグメントの場合、*super.onAttach*を呼び出した後、*onAttach*メソッドを使用してコンポーネントを注入します。

```EnterDetailsFragment.kt
class EnterDetailsFragment : Fragment() {

    override fun onAttach(context: Context) {
        super.onAttach(context)

        (activity!!.application as MyApplication).appComponent.inject(this)
    }
}
```

> **重要** - **ベストプラクティス**
> アクティビティは、*onCreate*メソッドで*super*を呼び出す前にDaggerを注入します。
> フラグメントは、*onAttach*メソッドでsuperを呼び出した後にDaggerを注入します。

Daggerが知る必要があるのは、*EnterDetailsViewModel*のインスタンスを提供する方法です。そのためには、コンストラクタに*@Inject*アノテーションを付けます。*RegistrationViewModel*にはすでに*@Inject*アノテーションが付けられており、*RegistrationActivity*にはそれが必要でした。

```EnterDetailsViewModel.kt
class EnterDetailsViewModel @Inject constructor() { ... }
```

*EnterDetailsFragment*の準備ができました。*TermsAndConditionsFragment*でも同じようにする必要があります。

1. Daggerに提供するフィールド（*registrationViewModel*）に*@Inject*アノテーションを付け、プライベート可視性修飾子を削除します。
2. 手動の依存性注入に必要な*registrationViewModel*インスタンスを削除します。
3. *onAttach*メソッドにDaggerを注入します。

```TermsAndConditionsFragment.kt
class TermsAndConditionsFragment : Fragment() {

    @Inject
    lateinit var registrationViewModel: RegistrationViewModel

    override fun onAttach(context: Context) {
        super.onAttach(context)

        (activity!!.application as MyApplication).appComponent.inject(this)
    }

    override fun onCreateView(...): View? {
         ...
         // Remove following line
         registrationViewModel = (activity as RegistrationActivity).registrationViewModel
         ...
    }
}
```

これで、アプリを実行できます。
何が起こった？クラッシュしました！問題は、*RegistrationViewModel*の異なるインスタンスが*RegistrationActivity*、*EnterDetailsFragment*、および*TermsAndConditionsFragment*に挿入されていることです。しかし、それは私たちが望むものではありません。ActivityとFragmentsに同じインスタンスを注入する必要があります。
*RegistrationViewModel*に*@Singleton*で注釈を付けるとどうなりますか？ それは今のところ問題を解決するでしょうが、将来的には問題を引き起こすでしょう

- 登録フローが終了した後、*RegistrationViewModel*のインスタンスが常にメモリにあることは望ましくありません。
- 登録フローごとにRegistrationViewModelの異なるインスタンスが必要です。ユーザーが登録および登録解除する場合、以前の登録データが存在することは望ましくありません。

登録フラグメントには、アクティビティから同じViewModelを再利用する必要がありますが、アクティビティが変更された場合、別のインスタンスが必要です。*RegistrationViewModel*を*RegistrationActivity*にスコープする必要があります。そのために、登録フローの新しいコンポーネントを作成し、*ViewModel*をその新しい登録コンポーネントにスコープすることができます。**Daggerのsubcomponents**を使用します。

## Dagger Subcomponents
*RegistrationViewModel*は*UserRepository*に依存するため、*RegistrationComponent*は*AppComponent*からオブジェクトにアクセスできる必要があります。新しいコンポーネントが別のコンポーネントの一部を使用することをDaggerに伝える方法は、**Dagger Subcomponents**を使用することです。新しいコンポーネント（*RegistrationComponent*）は、共有リソースを含むコンポーネント（つまり*AppComponent*）のサブコンポーネントである必要があります。

> **Subcomponents**は、親コンポーネントのオブジェクトグラフを継承および拡張するコンポーネントです。したがって、親コンポーネントで提供されるすべてのオブジェクトは、サブコンポーネントでも提供されます。このようにして、サブコンポーネントのオブジェクトは、親コンポーネントによって提供されるオブジェクトに依存できます。

これは登録に固有のものであるため、登録パッケージ内に新しい*RegistrationComponent.kt*ファイルを作成します。ここで、これがサブコンポーネントであることをDaggerに伝える*@Subcomponent*アノテーションが付いた*RegistrationComponent*という新しいインターフェイスを作成できます。

```app/src/main/java/com/example/android/dagger/registration/RegistrationComponent.kt
package com.example.android.dagger.registration

import dagger.Subcomponent

// Definition of a Dagger subcomponent
@Subcomponent
interface RegistrationComponent {

}
```

このコンポーネントには、登録固有の情報を含める必要があります。 そのためには、次のことが必要です。

1. 登録固有のAppComponentから注入メソッドを追加します。RegistrationActivity、EnterDetailsFragment、およびTermsAndConditionsFragment。
2. このサブコンポーネントのインスタンスを作成するために使用できるサブコンポーネントファクトリを作成します。

```RegistrationComponent.kt
// Daggerサブコンポーネントの定義
@Subcomponent
interface RegistrationComponent {

    // RegistrationComponentのインスタンスを作成するファクトリー
    @Subcomponent.Factory
    interface Factory {
        fun create(): RegistrationComponent
    }

    // Classes that can be injected by this Component
    fun inject(activity: RegistrationActivity)
    fun inject(fragment: EnterDetailsFragment)
    fun inject(fragment: TermsAndConditionsFragment)
}
```

*AppComponent*では、登録ビュークラスを使用できなくなるため、登録ビュークラスを挿入できるメソッドを削除する必要があります。これらのクラスは*RegistrationComponent*を使用します。
代わりに、*RegistrationActivity*が*RegistrationComponent*のインスタンスを作成するには、*AppComponent*インターフェイスでファクトリを公開する必要があります。

```AppComponent.kt
@Singleton
@Component(modules = [StorageModule::class])
interface AppComponent {

    @Component.Factory
    interface Factory {
        fun create(@BindsInstance context: Context): AppComponent
    }

    // グラフから登録コンポーネントファクトリを公開する
    fun registrationComponent(): RegistrationComponent.Factory

    fun inject(activity: MainActivity)
}
```

戻り値の型としてそのクラスを使用して関数を宣言することにより、*RegistrationComponent*ファクトリを公開します。

> ダガーグラフを操作するには、2つの異なる方法があります。]
> 1. Unitを返し、クラスをパラメーターとして受け取る関数を宣言すると、そのクラスでのフィールドインジェクションが許可されます(例：*fun inject(activity: MainActivity)*)。
> 2. 型を返す関数を宣言すると、グラフから型を取得できます(例：*fun registrationComponent(): RegistrationComponent.Factory*)。

次に、*RegistrationComponent*がサブコンポーネントであることを*AppComponent*に認識させ、そのためのコードを生成できるようにする必要があります。これを行うには、Daggerモジュールを作成する必要があります。

diパッケージに*AppSubcomponents.kt*というファイルを作成してみましょう。そのファイルでは、*@Module*アノテーションが付けられた*AppSubcomponents*というクラスを定義します。サブコンポーネントに関する情報を指定するには、次のように、アノテーションのサブコンポーネント変数にコンポーネントクラス名のリストを追加します。

```app/src/main/java/com/example/android/dagger/di/AppSubcomponents.kt
// This module tells AppComponent which are its subcomponents
@Module(subcomponents = [RegistrationComponent::class])
class AppSubcomponents
```

この新しいモジュールもAppComponentに含める必要があります。

```AppComponent.kt
@Singleton
@Component(modules = [StorageModule::class, AppSubcomponents::class])
interface AppComponent { ... }
```

アプリケーショングラフはどのようになりましたか？
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/170755/a4de5843-d28b-0b0f-3095-29c58837177e.png)

登録固有のビュークラスは、*RegistrationComponent*によって挿入されます。
*RegistrationViewModel*と*EnterDetailsViewModel*は*RegistrationComponent*を使用するクラスによってのみ要求されるため、それらは*RegistrationComponent*の一部です。AppComponentの一部ではありません。

# 11.スコーピングサブコンポーネント
アクティビティとフラグメント間で*RegistrationViewModel*の同じインスタンスを共有する必要があるため、サブコンポーネントを作成しました。前と同じように、同じスコープアノテーションでコンポーネントとクラスにアノテーションを付けると、その型はコンポーネント内に一意のインスタンスを持つようになります。
ただし、*@Singleton*は*AppComponent*で既に使用されているため使用できません。 別のものを作成する必要があります。
この場合、このスコープを*@RegistrationScope*と呼ぶことができますが、これは良い習慣ではありません。スコープアノテーションの名前は、それが果たす目的を明示するものであってはなりません。注釈は兄弟コンポーネント（LoginComponent、SettingsComponentなど）によって再利用できるため、有効期間に応じて名前を付ける必要があります。そのため、*@RegistrationScope*と呼ぶ代わりに*@ActivityScope*と呼びます。

> **スコープ規則**：
> ・タイプがスコープアノテーションでマークされている場合、同じスコープでアノテーションが付けられているコンポーネントでのみ使用できます。
> ・コンポーネントがスコープアノテーションでマークされている場合、そのアノテーションを持つ型またはアノテーションのない型のみを提供できます。サブコンポーネントは、その親コンポーネントの1つが使用するスコープアノテーションを使用できません。
> 
> コンポーネントには、このコンテキストのサブコンポーネントも含まれます。

diパッケージにActivityScope.ktというファイルを作成し、次のようにActivityScopeの定義を追加しましょう。

```app/src/main/java/com/example/android/dagger/di/ActivityScope.kt
@Scope
@MustBeDocumented
@Retention(value = AnnotationRetention.RUNTIME)
annotation class ActivityScope
```

*RegistrationViewModel*を*RegistrationComponent*にスコープするには、クラスとインターフェイスの両方に*@ActivityScope*の注釈を付ける必要があります。

```RegistrationViewModel.kt
// ViewModelからコンポーネントへのスコープ*@ActivityScope*を使用する
@ActivityScope
class RegistrationViewModel @Inject constructor(val userManager: UserManager) {
    ...
}
```

```RegistrationComponent.kt
// RegistrationComponentが使用するアノテーションスコープ
// *@ActivityScope*アノテーションが付けられたクラスは、このコンポーネントに一意のインスタンスを持ちます
@ActivityScope
@Subcomponent
interface RegistrationComponent { ... }
```

*RegistrationComponent*のインスタンスが*RegistrationViewModel*のインスタンスを提供するたびに、それは同じものになります。

# サブコンポーネントのライフサイクル
アプリケーションがメモリ内にある限り、グラフの同じインスタンスを使用するため、AppComponentはアプリケーションのライフサイクルにアタッチされます。
RegistrationComponentのライフサイクルは何ですか？必要な理由の1つは、*RegistrationViewMode*の同じインスタンスを登録アクティビティとフラグメント間で共有したかったためです。しかし、また、新しい登録フローがあるたびに、RegistrationViewModelの異なるインスタンスが必要です。
*RegistrationActivity*は、*RegistrationComponent*の適切なライフタイムです。新しいアクティビティごとに、*RegistrationComponent*のインスタンスを使用できる新しい*RegistrationComponent*とフラグメントを作成します。
*RegistrationComponent*は*RegistrationActivity*ライフサイクルにアタッチされているため、Applicationクラスで*appComponent*への参照を保持したのと同じ方法で、Activityでコンポーネントへの参照を保持する必要があります。このようにして、フラグメントはそれにアクセスできるようになります。

```RegistrationActivity.kt
class RegistrationActivity : AppCompatActivity() {

    // RegistrationComponentのインスタンスを保存して、そのフラグメントがアクセスできるようにします
    lateinit var registrationComponent: RegistrationComponent
    ...
}
```

また、アクティビティを*appComponent*に注入する代わりに、*super.onCreate*を呼び出して*registrationComponent*を注入する前に、*onCreate*メソッドで*RegistrationComponent*の新しいインスタンスを作成する必要があります。

1. *appComponent*からファクトリーを取得し、createを呼び出して、*RegistrationComponent*の新しいインスタンスを作成します。これは、*RegistrationComponent*ファクトリのインスタンスを返すために*AppComponent*インターフェイスで関数*registrationComponent*を公開するために可能です。
2. そのインスタンスをアクティビティの*registrationComponent*変数に割り当てます。
3. 最近作成されたregistrationComponentにアクティビティを注入して、フィールド注入を実行し、*@Inject*アノテーションが付けられたフィールドに入力します。

```RegistrationActivity.kt
class RegistrationActivity : AppCompatActivity() {
    ...

    override fun onCreate(savedInstanceState: Bundle?) {

        // 行を削除
        (application as MyApplication).appComponent.inject(this)

        // これらの行を追加

        // アプリグラフからファクトリを取得することにより、登録コンポーネントのインスタンスを作成します
        // registrationComponent = (application as MyApplication).appComponent.registrationComponent().create() 
        // このアクティビティを、作成したばかりの登録コンポーネントに挿入します
        registrationComponent.inject(this)

        super.onCreate(savedInstanceState)
        ...
    }
    ...
}
```

> 気づいたら、変数registrationComponentには@Injectアノテーションが付けられていません。その変数がDaggerによって提供されることを期待していないためです。

*registrationComponent*は*RegistrationActivity*で使用でき、そのインスタンスを使用して登録フラグメントを注入できます。アクティビティの*registrationComponent*を使用するには、フラグメントの*onAttach*メソッドを置き換えます。

```EnterDetailsFragment.kt
class EnterDetailsFragment : Fragment() {
    ...
    override fun onAttach(context: Context) {
        super.onAttach(context)

        (activity as RegistrationActivity).registrationComponent.inject(this)
    }
    ...
}
```

そして、TermsAndConditionsフラグメントにも同じことを行います。

```TermsAndConditionsFragment.kt
class TermsAndConditionsFragment : Fragment() {
    ...
    override fun onAttach(context: Context) {
        super.onAttach(context)

        (activity as RegistrationActivity).registrationComponent.inject(this)
    }
}
```

アプリを再度を実行し、以前のように登録フローに移動して新規に開始すると、登録フローが期待どおりに機能することがわかります。

これは、アプリケーショングラフがどのように見えるかです。
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/170755/2305fa89-f9f3-6c90-3e19-452d6ae37e36.png)
前の図との違いは、*RegistrationViewModel*が*RegistrationComponent*にスコープされていることです。*RegistrationViewModel*にオレンジ色のドットでそれを表します。

> *注意*：構成の変更に耐えるためにコンテナが必要な場合は、UI状態の保存ガイドに従ってください。プロセスの停止を処理するのと同じ方法で処理したい場合があります。そうしないと、ローエンドデバイスでアプリの状態が失われる可能性があります。

# 12.ログインフローのリファクタリング
オブジェクトを異なるライフサイクルにスコープすることとは別に、サブコンポーネントを作成することは、アプリケーションの異なる部分を互いにカプセル化するための良い習慣です。
アプリの構造に応じてアプリのフローに応じて異なるダガーサブグラフを作成すると、メモリと起動時間の点でパフォーマンスと拡張性に優れたアプリケーションになります。ベストプラクティスの反対は、アプリケーションのすべてのオブジェクトを提供する方法を知っているモノリシックコンポーネントを持つことです。Daggerコンポーネントの読み取りとモジュール化をより困難にします。
ログインフローをリファクタリングして、Daggerを使用してログインフロー用の別のサブコンポーネントを作成しましょう。
ログインパッケージに*LoginComponent.kt*というファイルを作成し、*RegistrationComponent*で行ったように*LoginComponent*の定義を追加しますが、今回はLogin関連クラスを使用します。

```app/src/main/java/com/example/android/dagger/login/LoginComponent.kt
// LoginComponentが使用するスコープアノテーション
// @ActivityScopeアノテーションが付けられたクラスは、このコンポーネントで一意のインスタンスを持ちます
@ActivityScope
// Daggerサブコンポーネントの定義
@Subcomponent
interface LoginComponent {

    // LoginComponentのインスタンスを作成するファクトリー
    @Subcomponent.Factory
    interface Factory {
        fun create(): LoginComponent
    }

    // このコンポーネントによって注入できるクラス
    fun inject(activity: LoginActivity)
}
```

コンポーネントの有効期間は*LoginActivity*と同じであるため、*LoginComponent*に*ActivityScope*でアノテーションを付けることができます。
*LoginViewModel*のインスタンスを作成する方法をDaggerに伝えるために、コンストラクタに@Injectアノテーションを付けます。

```LoginViewModel.kt
class LoginViewModel @Inject constructor(private val userManager: UserManager) {
    ...
}
```

この場合、*LoginViewModel*を他のクラスで再利用する必要はありません。そのため、*@ActivityScope*アノテーションを付けないでください。
また、*AppSubcomponents*モジュールの*AppComponent*のサブコンポーネントのリストに新しいサブコンポーネントを追加する必要があります。

```AppSubcomponents.kt
@Module(subcomponents = [RegistrationComponent::class, LoginComponent::class])
class AppSubcomponents
```

*LoginActivity*が*LoginComponent*ファクトリにアクセスできるようにするには、*AppComponent*インターフェースで公開する必要があります。

```AppComponent.kt
@Singleton
@Component(modules = [StorageModule::class, AppSubcomponents::class])
interface AppComponent {
    ...
    // グラフから取得できる型
    fun registrationComponent(): RegistrationComponent.Factory
    fun loginComponent(): LoginComponent.Factory

    // このコンポーネントによって注入できるクラス
    fun inject(activity: MainActivity)
}
```

*LoginComponent*のインスタンスを作成し、*LoginActivity*に注入する準備がすべて整いました。

1. Daggerによって提供されるようにするため、*loginViewModel*フィールドに*@Inject*の注釈を付けます。そしてprivate修飾子を削除します。
2. *loginComponent()*メソッドを呼び出す*appComponent*から*LoginComponent*ファクトリを取得します。*create()*で*LoginComponent*のインスタンスを作成します。アクティビティを渡す*Component*の*inject*メソッドを呼び出します。
3. 以前の手動依存性注入の実装から*loginViewModel*のインスタンス化を削除します。

```LoginActivity.kt
class LoginActivity : AppCompatActivity() {

    // 1) LoginViewModelはDaggerによって提供されます
    @Inject
    lateinit var loginViewModel: LoginViewModel

    ...

    override fun onCreate(savedInstanceState: Bundle?) {

        // 2) アプリグラフからファクトリを取得して、ログインコンポーネントのインスタンスを作成します
        // このアクティビティをそのコンポーネントに注入します
        (application as MyApplication).appComponent.loginComponent().create().inject(this)

        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_login)

        // 3) インスタンス化を削除
        loginViewModel = LoginViewModel((application as MyApplication).userManager)
        ...
    }
}
```

アプリを再度を実行すると、設定を除くすべてが機能します。これは、設定がDaggerを使用するようにリファクタリングされておらず、UserManagerの別のインスタンスを使用しているためです。
新しいログインコンポーネントでは、アプリケーショングラフは次のようになります。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/170755/9f058643-227f-bc2c-1e79-43cac9fae20f.png)

> この時点でのコードラボのソリューションは、Githubプロジェクトの*2_subcomponents*ブランチにあります。

# 13.同じスコープを持つ複数のアクティビティ
Daggerを使用するように設定をリファクタリングしましょう。*SettingsActivity*フィールドをDaggerによって挿入する必要があるため：

1.Daggerに、コンストラクターに@Injectアノテーションを付けて、*SettingsActivity*依存関係（つまり、*SettingsViewModel*）のインスタンスを作成する方法を伝えます。Daggerは、*SettingsViewModel*依存関係のインスタンスを作成する方法をすでに知っています。

```SettingsViewModel.kt
class SettingsViewModel @Inject constructor(
    private val userDataRepository: UserDataRepository,
    private val userManager: UserManager
) { ... }
```

2.*AppComponent*インターフェースの*SettingsActivity*をパラメーターとして使用する関数を追加することにより、*SettingsActivity*がDaggerによって注入されることを許可します。

```AppComponent.kt
@Singleton
@Component(modules = [StorageModule::class, AppSubcomponents::class])
interface AppComponent {
    ...
    fun inject(activity: SettingsActivity)
}
```

3.*SettingsActivity*で、挿入されたフィールドに*@Inject*のアノテーションを付け、private修飾子を削除します。
4.*MyApplication*から*appComponent*にアクセスするアクティビティを挿入して、*inject(this)を呼び出して、*@Inject*アノテーションが付けられたフィールドに入力します。
5.手動の依存関係注入の古い実装に必要なインスタンス化を削除します。

```SettingsActivity.kt
class SettingsActivity : AppCompatActivity() {

    // 1) SettingsViewModelはDaggerによって提供されます
    @Inject
    lateinit var settingsViewModel: SettingsViewModel

    override fun onCreate(savedInstanceState: Bundle?) {

        // 2) appComponentを注入します
        (application as MyApplication).appComponent.inject(this)

        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_settings)

        // 3) 次の行を削除
        val userManager = (application as MyApplication).userManager
        settingsViewModel = SettingsViewModel(userManager.userDataRepository!!, userManager)
        ...
    }
}
```

アプリを実行すると、[設定]の[通知の更新]機能が機能しないことがわかります。 これは、*MainActivity*と*SettingsActivity*で*UserDataRepository*の同じインスタンスを再利用していないためです！
*@Singleton*アノテーションを付けることで、*UserDataRepository*を*AppComponent*にスコープできますか？前と同じ推論に従って、ユーザーがログアウトまたは登録解除した場合、*UserDataRepository*の同じインスタンスをメモリに保持したくないため、これを行いたくありません。そのデータは、ログインしているユーザーに固有です。
ユーザーがログインしている限り有効なコンポーネントを作成します。ユーザーがログインした後にアクセスできるすべてのアクティビティは、このコンポーネント（つまり、*MainActivity*と*SettingsActivity*）によって注入されます
*LoginComponent*と*RegistrationComponent*で行ったように*UserComponent*を呼び出すことができる別のサブコンポーネントを作成しましょう。
1.ユーザーフォルダーにUserComponent.ktというKotlinファイルを作成します。
2.*@Subcomponent*アノテーションが付けられた*UserComponent*という名前のインターフェイスを作成します。このインターフェイスは、ユーザーがログインしてファクトリーを作成した後に発生するクラスを挿入できます。

```app/src/main/java/com/example/android/dagger/user/UserComponent.kt
// Daggerサブコンポーネントの定義
@Subcomponent
interface UserComponent {

    // UserComponentのインスタンスを作成するファクトリ
    @Subcomponent.Factory
    interface Factory {
        fun create(): UserComponent
    }

    // このコンポーネントによって注入できるクラス
    fun inject(activity: MainActivity)
    fun inject(activity: SettingsActivity)
}
```

3.この新しいサブコンポーネントを、*AppSubcomponents.kt*ファイル内の*AppComponent*のサブコンポーネントのリストに追加します。

```AppSubcomponents.kt
@Module(subcomponents = [RegistrationComponent::class, LoginComponent::class, UserComponent::class])
class AppSubcomponents
```

*UserComponent*のライフタイムを担当しているのは何ですか？*LoginComponent*と*RegistrationComponent*はそのアクティビティによって管理されますが、*UserComponent*は複数のアクティビティを挿入でき、アクティビティの数が増加する可能性があります。
このコンポーネントの有効期間を、ユーザーがいつログインおよびログアウトしたかを知っているものにアタッチする必要があります。この場合、*UserManager*が実行します。 *UserManager*は、登録、ログイン、およびログアウトの試行を処理します。*UserComponent*インスタンスが存在することは理にかなっています。
*UserManager*が*UserComponent*の新しいインスタンスを作成する必要がある場合、*UserComponent*ファクトリにアクセスする必要があります。ファクトリをコンストラクタパラメータとして追加すると、*UserManager*のインスタンスを作成するときにDaggerが提供します。

```UserManager.kt
@Singleton
class UserManager @Inject constructor(
    private val storage: Storage,
    // UserManagerはUserComponentライフサイクルの管理を担当するため、
    // インスタンスの作成方法を知る必要があります
    private val userComponentFactory: UserComponent.Factory
) {
    ...
}
```

手動の依存性注入では、セッションのユーザーデータを*UserManager*に保存しました。これで、ユーザーがログインしているかどうかが決まりました。代わりに*UserComponent*でも同じことができます。
*UserManager*に*UserComponent*のインスタンスを保持して、その有効期間を管理できます。*UserComponent*が*null*でない場合、ユーザーはログインします。 ユーザーがログアウトすると、*UserComponent*のインスタンスを削除できます。このように、*UserComponent*には特定のユーザーに関連するクラスのすべてのデータとインスタンスが含まれているため、ユーザーがログアウトすると、コンポーネントを破棄すると、すべてのデータがメモリから削除されます。
*UserDataRepository*の代わりに*UserComponent*のインスタンスを使用するように*UserManager*を変更します。

```UserManager.kt
@Singleton
class UserManager @Inject constructor(...) {
    // 行を削除
    var userDataRepository: UserDataRepository? = null

    var userComponent: UserComponent? = null
          private set

    fun isUserLoggedIn() = userComponent != null

    fun logout() {
        userComponent = null
    }

    private fun userJustLoggedIn() {
        userComponent = userComponentFactory.create()
    }
}
```

上記のコードでわかるように、ユーザーが*UserComponent*ファクトリの*create*メソッドを使用してログインすると、*userComponent*のインスタンスが作成されます。そして、*logout()*が呼び出されたときにインスタンスを削除します。
*MainActivity*と*SettingsActivity*の両方が同じインスタンスを共有できるように、*UserDataRepository*を*UserComponent*にスコープする必要があります。
有効期間を管理するアクティビティを持つコンポーネントに注釈を付けるためにスコープアノテーション*@ActivityScope*を使用しているため、すべてのアプリケーションではなく、複数のアクティビティをカバーできるスコープが必要です。そのようなものはまだないので、新しいスコープを作成する必要があります。
このスコープは、ユーザーがログインしたときのライフタイムをカバーするため、*LoggedUserScope*と呼ぶことができます。
ユーザーパッケージに*LoggedUserScope.kt*という新しいKotlinファイルを作成し、*LoggedUserScope*スコープアノテーションを次のように定義します。

```app/src/main/java/com/example/android/dagger/user/LoggedUserScope.kt
@Scope
@MustBeDocumented
@Retention(value = AnnotationRetention.RUNTIME)
annotation class LoggedUserScope
```

*UserComponent*が常に*UserDataRepository*の同じインスタンスを提供できるように、*UserComponent*と*UserDataRepository*の両方にこの注釈を付けることができます。

```UserComponent.kt
// UserComponentが使用するスコープ注釈
// *@LoggedUserScope*アノテーションが付けられたクラスには、このコンポーネントに一意のインスタンスがあります
@LoggedUserScope
@Subcomponent
interface UserComponent { ... }
```

```UserDataRepository.kt
// このオブジェクトには、@ LoggedUserScopeの注釈が付けられたコンポーネントに
// 一意のインスタンスがあります（この場合はUserComponentのみ）。
@LoggedUserScope
class UserDataRepository @Inject constructor(private val userManager: UserManager) {
    ...
}
```

*MyApplication*クラスには、手動の依存性注入の実装に必要な*userManager*のインスタンスを保存しました。このアプリはDaggerを使用するために完全にリファクタリングされているため、もう必要ありません。*MyApplication*は次のようになります。

```MyApplication.kt
open class MyApplication : Application() {

    val appComponent: AppComponent by lazy {
        DaggerAppComponent.factory().create(applicationContext)
    }
}
```

*AppComponent*も変更する必要があります。

1. *MainActivity*と*SettingsActivity*はこのコンポーネントによってもう注入されないので、注入メソッドを削除します。これらは*UserComponent*を使用します。
2. *MainActivity*および*SettingsActivity*が*UserComponent*のインスタンスにアクセスするために必要とするため、グラフから*UserManager*を公開します。

```AppComponent.kt
@Singleton
@Component(modules = [StorageModule::class, AppSubcomponents::class])
interface AppComponent {
    ... 
    // 2) MainActivityとSettingsActivityがUserComponentの特定のインスタンスに
    //    アクセスできるように、UserManagerを公開します
    fun userManager(): UserManager

    // 1) 次の行を削除
    fun inject(activity: MainActivity)
    fun inject(activity: SettingsActivity)
}
```

*SettingsActivity*で、*@Inject*を使用して*ViewModel*に注釈を付け（Daggerによって注入されるようにするため）、プライベート修飾子を削除します。ユーザーがログインしているために初期化される*UserComponent*のインスタンスを取得するには、*appComponent*が公開する*userManager()*メソッドを呼び出します。これで、内部の*userComponent*にアクセスして、アクティビティを注入できます。

```SettingsActivity.kt
class SettingsActivity : AppCompatActivity() {
    // @Inject注釈付きフィールドはDaggerによって提供されます
    @Inject
    lateinit var settingsViewModel: SettingsViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        // アプリケーショングラフからuserManagerを取得してUserComponentのインスタンスを取得し、
        // このアクティビティを挿入します
        val userManager = (application as MyApplication).appComponent.userManager()
        userManager.userComponent!!.inject(this)

        super.onCreate(savedInstanceState)
        ...
    }
    ...
}
```

*MainActivity*は、*UserComponent*を注入するために同じことを行います。

1. *UserManager*は*appComponent*から直接取得できるため、もう注入しないでください。 *userManager*フィールドを削除する
2. ユーザーがログインしているかどうかを確認する前に、ローカル変数を作成します。
3. *UserComponent*はユーザーがログインしている場合にのみ利用できるため、*userManager*から*userComponent*を取得し、elseブランチにアクティビティを注入します。

```MainActivity.kt
class MainActivity : AppCompatActivity() {

    // 1) userManagerフィールドを削除
    @Inject
    lateinit var userManager: UserManager

    @Inject
    lateinit var mainViewModel: MainViewModel

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

        // 2) appComponentからuserManagerを取得して、ユーザーがログインしているかどうかを確認します
        val userManager = (application as MyApplication).appComponent.userManager()
        if (!userManager.isUserLoggedIn()) { ... }
        else {
            setContentView(R.layout.activity_main)
            // 3) MainActivityを表示する必要がある場合、
            // アプリケーショングラフからUserComponentを取得し、このアクティビティを挿入します
            userManager.userComponent!!.inject(this)
            setupViews()
        }
    }
    ...
}
```

> **重要**：条件付きフィールドインジェクション（ユーザーがログインしている場合にのみインジェクトするときMainActivity.ktで行うように）を行うことは非常に危険です。開発者は条件に注意する必要があり、注入されたフィールドとやり取りするときにNullPointerExceptionsを取得するリスクがあります。
> この問題を回避するために、ユーザーの状態に応じて登録、ログイン、またはメインのいずれかにルーティングする*SplashScreen*を作成することにより、間接性を追加できます。これは、作業割り当てに関するコードラボの最後のセクションのトピックになります。

アプリのすべての画面は、Daggerにリファクタリングされました！アプリを実行すると、すべてが期待どおりに動作するようになりました。
*UserComponent*を追加すると、アプリケーショングラフは次のようになります。
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/170755/d25f73bf-682e-2fbe-0c33-dfe57aa3048f.png)

> この時点でのコードラボのソリューションは、Githubプロジェクトの*3_dagger_app*ブランチにあります。

# 14. Daggerを使用したテスト
Daggerのような依存性注入フレームワークを使用する利点の1つは、コードのテストが簡単になることです。

## Unit tests
単体テストにDagger関連のコードを使用する必要はありません。コンストラクター注入を使用するクラスをテストする場合、そのクラスをインスタンス化するためにDaggerを使用する必要はありません。フェイクの依存関係またはモックの依存関係を渡すコンストラクタを直接呼び出すことができます。
たとえば、*LoginViewModel*をテストする*LoginViewModelTest.kt*ファイルを見ると、*UserManager*をモックして、Daggerを使用しない場合と同様にパラメーターとして渡すだけです。

```LoginViewModelTest.kt
class LoginViewModelTest {
    ...
    private lateinit var viewModel: LoginViewModel
    private lateinit var userManager: UserManager

    @Before
    fun setup() {
        userManager = mock(UserManager::class.java)
        viewModel = LoginViewModel(userManager)
    }

    @Test
    fun `Get username`() {
        whenever(userManager.username).thenReturn("Username")

        val username = viewModel.getUsername()

        assertEquals("Username", username)
    }
    ...
}
```

すべての単体テストは、1つを除き、手動の依存関係注入と同じままです。*UserComponent.Factory*を*UserManager*に追加したときに、ユニットテストを中断しました。ファクトリで*create()*を呼び出すときにDaggerが返すものをモックする必要があります。
もしかして: Open the UserManager Test.kt file and create and configure mocks for the User Component factory as follows:
*UserManagerTest.kt*ファイルを開き、次のように*UserComponent*ファクトリのモックを作成および構成します。

```UserManagerTest.kt
class UserManagerTest {
    ...

    @Before
    fun setup() {
        // ファクトリを呼び出すときに、模擬*userComponent*を返します
        val userComponentFactory = Mockito.mock(UserComponent.Factory::class.java)
        val userComponent = Mockito.mock(UserComponent::class.java)
        `when`(userComponentFactory.create()).thenReturn(userComponent)

        storage = FakeStorage()
        userManager = UserManager(storage, userComponentFactory)
    }

    ...
}
```

これで、すべての単体テストに合格するはずです。

## エンドツーエンドのテスト
Daggerなしで統合テストを実行しました。プロジェクトにDaggerを導入し、MyApplicationクラスの実装を変更するとすぐに、それらを壊しました。

## インストルメンテーションテストでのカスタムアプリケーションの使用
以前は、エンドツーエンドテストでは*MyTestApplication*というカスタムアプリケーションを使用していました。別のアプリケーションを使用するには、新しい*TestRunner*を作成する必要がありました。
そのためのコードは、*app/src/androidTest/java/com/example/android/dagger/MyCustomTestRunner.kt*ファイルにあります。コードはすでにプロジェクトにあります。追加する必要はありません。

```MyCustomTestRunner.kt
class MyCustomTestRunner : AndroidJUnitRunner() {

    override fun newApplication(cl: ClassLoader?, name: String?, context: Context?): Application {
        return super.newApplication(cl, MyTestApplication::class.java.name, context)
    }
}
```

プロジェクトは、この*TestRunner*が*app/build.gradle*ファイルで指定されているため、インストルメンテーションテストを実行するときに使用する必要があることを知っています。

```app/build.gradle
...
android {
    ...
    defaultConfig {
        ...
        testInstrumentationRunner "com.example.android.dagger.MyCustomTestRunner"
    }
    ...
}
...
```

## 計装テストでのDaggerの使用
Daggerを使用するには、*MyTestApplication*を構成する必要があります。 統合テストの場合、テスト用の*TestApplicationComponent*を作成することをお勧めします。生産とテストは異なるコンポーネント構成を使用します。
テスト構成と実稼働構成の違いは何ですか？*UserManager*で*SharedPreferencesStorage*を使用する代わりに、*FakeStorage*を使用します。*SharedPreferencesStorage*を生成しているのは何ですか？ *StorageModule*。
*FakeStorage*を使用する別の*StorageModule*に*StorageModule*を交換する必要があります。
これはインストルメンテーションテストにのみ必要なため、この新しいクラスを*androidTest*フォルダーに作成します。
*app/src/androidTest/java/com/example/android/dagger/*内にdiという新しいパッケージを作成します。
そこで、パスが*app/src/androidTest/java/com/example/android/dagger/di/TestStorageModule.kt*である*TestStorageModule.kt*という新しいファイルを作成します。

```app/src/androidTest/java/com/example/android/dagger/di/TestStorageModule.kt
// AndroidテストでStorageModuleをオーバーライドします
@Module
abstract class TestStorageModule {

    // ストレージタイプが要求されたときにDaggerがFakeStorageを提供するようにします
    @Binds
    abstract fun provideStorage(storage: FakeStorage): Storage
}
```

*@Binds*の仕組みにより、*SharedPreferencesStorage*をパラメーターとして使用してメソッドを宣言する代わりに、
*TestStorageModule*の場合、*FakeStorage*をパラメーターとして渡します。これにより、次に作成する*TestAppComponent*がストレージのこの実装を使用するようになります。
Daggerは*FakeStorage*のインスタンスを作成する方法を知りませんが、いつものように、コンストラクタに*@Inject*アノテーションを付けます。

```FakeStorage.kt
class FakeStorage @Inject constructor(): Storage { ... }
```

ここで、Daggerがストレージタイプを要求したときに*FakeStorage*のインスタンスを提供します。生産とテストでは異なるコンポーネント構成を使用するため、*AppComponent*として機能する別のコンポーネントを作成する必要があります。*TestAppComponent*と呼びます。
次のパスに新しいKotlinファイルを作成しましょう
*app/src/androidTest/java/com/example/android/dagger/di/TestAppComponent.kt*

```app/src/androidTest/java/com/example/android/dagger/di/TestAppComponent.kt
@Singleton
@Component(modules = [TestStorageModule::class, , AppSubcomponents::class])
interface TestAppComponent : AppComponent
```

このテストコンポーネントのすべてのモジュールも指定する必要があります。*TestStorageModule*とは別に、サブコンポーネントに関する情報を追加する*AppSubcomponents*モジュールも含める必要があります。テストグラフにはコンテキストが必要ないため（以前にコンテキストが必要だった唯一の依存関係は*SharedPreferencesStorage*でした）、*TestAppComponent*のファクトリを定義する必要はありません。
アプリをビルドしようとすると、Daggerは*TestAppComponent*の実装を生成しないことがわかります。テストグラフを使用して*DaggerTestAppComponent*クラスを作成する必要があります。*kapt*が*androidTest*フォルダーで動作していないためです。次のように、Daggerアノテーションプロセッサアーティファクトを*androidTest*に追加する必要があります。

```app/build.gradle
...
dependencies {
    ...
    kaptAndroidTest "com.google.dagger:dagger-compiler:$dagger_version"
}
```

プロジェクトを同期してアプリをビルドすると、*DaggerTestAppComponent*が使用可能になります。そうでない場合は、*androidTest*フォルダーでまだ動作していないためです。*androidTest*フォルダー内のjavaフォルダーを右クリックしてインストルメンテーションテストを実行し、「すべてのテストを実行」をクリックします。
*MyTestApplication*が独自のDaggerコンポーネントを作成できるようにするには、*MyApplication*にいくつかの変更を加える必要があります。
by lazy bodyレ内による*appComponent*の初期化を別のメソッドに抽出します。*initializeComponents()*という*MyTestComponent*でオーバーライドして、開くことができます。

```MyApplication.kt
open class MyApplication : Application() {

    val appComponent: AppComponent by lazy {
        initializeComponent()
    }

    open fun initializeComponent(): AppComponent {
        return DaggerAppComponent.factory().create(applicationContext)
    }
}
```

これで、*My Application*をサブクラス化し、*MyTest Application*で*Test AppComponent*を使用できます。

1. *userManager*インスタンスを削除します
2. *initializeComponent*メソッドをオーバーライドして、*DaggerTestAppComponent*のインスタンスを返すようにします。

```MyTestApplication.kt
class MyTestApplication : MyApplication() {

    override fun initializeComponent(): AppComponent {
        // フェイクタイプを注入する新しいTestAppComponentを作成します
        return DaggerTestAppComponent.create()
    }
}
```

> **注意**：*DaggerTestAppComponent*をインポートできない場合は、以下に指定されているインストルメンテーションテストを実行してから、インポートを試行してください。プロジェクトは*androidTest*構成にないため、そのクラスは生成されません。

これでテストに合格するはずです。*androidTest/java/com/example/android/daggerフォルダーの*ApplicationTest.kt*ファイルを開き、クラス定義の横にある実行ボタンをクリックします。テストが実行されてパスするはずです。

> この時点でのコードラボのソリューションは、Githubプロジェクトの*solution*ブランチにあります。

# 15. @Provides注釈と修飾子
Androidプロジェクトで役立つ他のアノテーションがあります。

## @Provides
*@Inject*および*@Binds*アノテーションとは別に、*@Provides*を使用して、DaggerにDaggerモジュール内のクラスのインスタンスを提供する方法を指示できます。
*@Provides*関数の戻り値の型（関数の呼び出し方法は関係ありません）は、Daggerのグラフに追加される型を伝えます。その関数のパラメーターは、その型のインスタンスを提供する前にDaggerが満たす必要がある依存関係です。
この例では、次のように*Storage*タイプの実装も提供できます。

```StorageModule.kt
@Module
class StorageModule {

    // @Providesは、この関数が返す型（つまり、ストレージ）
    // のインスタンスを作成する方法をDaggerに伝えます。
    // 関数パラメーターは、このタイプの依存関係（つまり、コンテキスト）です。
    @Provides
    fun provideStorage(context: Context): Storage {
        // DaggerがStorageタイプのインスタンスを提供する必要があるときはいつでも、
        // このコード（@Providesメソッド内のコード）が実行されます。
        return SharedPreferencesStorage(context)
    }
}
```

Daggerモジュールで*@Provides*アノテーションを使用して、Daggerに提供方法を伝えることができます。

- インターフェースの実装（ただし、*@Binds*は、生成されるコードが少なく、より効率的であるため推奨されます）
- プロジェクトが所有していないクラス（*Retrofit*のインスタンスなど）

## 修飾子
プロジェクトのDagger修飾子は単純であるため、使用する必要はありませんでした。修飾子は、同じタイプの異なる実装をDaggerグラフに追加する場合に役立ちます。たとえば、異なる*Storage*オブジェクトを提供したい場合、修飾子を使用してそれらを区別できます。

> 修飾子は、依存関係を識別するために使用されるカスタムアノテーションです。

たとえば、ファイル名をパラメータとして使用するSharedPreferencesStorageがある場合

```SharedPreferencesStorage.kt
class SharedPreferencesStorage @Inject constructor(name: String, context: Context) : Storage {

    private val sharedPreferences = context.getSharedPreferences(name, Context.MODE_PRIVATE)

    ...
}
```

*StorageModule*の*@Provides*を使用して、さまざまな実装を追加できます。修飾子を使用して、実装の種類を識別できます。

```StorageModule.kt
@Retention(AnnotationRetention.BINARY)
@Qualifier
annotation class RegistrationStorage

@Retention(AnnotationRetention.BINARY)
@Qualifier
annotation class LoginStorage

@Module
class StorageModule {

    @RegistrationStorage
    @Provides
    fun provideRegistrationStorage(context: Context): Storage {
        return SharedPreferencesStorage("registration", context)
    }

    @LoginStorage
    @Provides
    fun provideLoginStorage(context: Context): Storage {
        return SharedPreferencesStorage("login", context)
    }
}
```

この例では、*@Provides*メソッドにアノテーションを付けるために使用できる*RegistrationStorage*と*LoginStorage*の2つの修飾子を定義しました。グラフには、*RegistrationStorage*と*LoginStorage*の2種類のストレージを追加しています。どちらのメソッドも*Storage*を返し、同じパラメーター（依存関係）を持ちますが、名前は異なります。*@Provides*関数の名前には機能がないため、次のように修飾子を使用してグラフから取得する必要があります。

## 修飾子を依存関係として取得する方法の例
```kotlin
// In a method
class ClassDependingOnStorage(@RegistrationStorage private val storage: Storage) { ... } 

// As an injected field
class ClassDependingOnStorage {

    @Inject
    @field:RegistrationStorage lateinit var storage: Storage
}
```

*@Named*アノテーションを使用して同じ修飾子の機能を実現できますが、次の理由で修飾子が推奨されます。

- ProguardまたはR8から削除できます
- 名前を一致させるために共有定数を保持する必要はありません
- それらは文書化することができます

# 16. [オプション]独自に依存性注入を試してください
コードラボアプリには、もう1つの試してみるための部分があります。それは、*SplashScreen*を使用するためのリファクタリングです。*MainActivity.kt*は、アプリを開くときに表示する必要がある画面のロジックを処理します。ユーザーが*MainActivity*にとどまるときにのみ注入する条件付き依存性注入を行っているため、これは問題です。
これらの手順にはコメントやコードが含まれていないため、自分で試してください。

- 表示する画面のロジックを処理する*SplashViewModel*で*SplashActivity*を作成します。
- これまでやってきたように、*SplashActivity*で依存性注入を使用して、Daggerによって注入されたフィールドを取得します。
- アクティビティが開かれるとユーザーがログインするため、*MainActivity.kt*の*onCreate*メソッドのロジックを削除します。

# 17.おめでとうございます！
これでDaggerに慣れてきたので、DaggerをAndroidアプリに追加できるはずです。 このコードラボでは、次のことを学びました。

- Daggerの*@Component*アノテーションを使用してアプリケーショングラフを作成する方法
- *@Inject*、*@Module*、*@Binds*および*@BindsInstance*アノテーションを使用して、グラフに情報を追加する方法
- *@Subcomponent*を使用してフローコンテナーを作成する方法
- スコープを使用して、異なるコンテナ内のオブジェクトのインスタンスを再利用する方法
- ダガー修飾子と*@Provides*アノテーション
- Daggerを使用するアプリケーションを単体テストとインストゥルメント化テストでテストする方法
-