AACのViewModelをFactoryクラス不要で簡単に生成できる拡張関数

Androidで、MVVM及びdatabindingを行う場合、Android Architecture ComponentsのViewModelを使うことが多いと思います。
このViewModelを生成する際、コンストラクタに引数が必要だとFactoryクラスを作成する必要がありますが、ViewModelが多くなってくるとその分Factoryも増えていき、作成・管理が面倒になったので拡張関数を作成しました。

# 結論
忙しい人のために先に結論
`Fragment.getViewModel`と `Fragment.viewModelProvider`を作りました。
## 使い方

```kotlin
class SampleFragment: Fragment(), SampleNavigator {
    // フィールドでvalで持ちたい場合は、viewModelProvider
    private val viewModel by viewModelProvider {
        val str = requireNotNull(arguments?.getString(ARG_SAMPLE_STR))
        SampleViewModel(str, this)
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val str= requireNotNull(arguments?.getString(ARG_SAMPLE_STR))
        // 一時的に使用したい(or lateinit varで初期化したい)場合はgetViewModel
        val vm = getViewModel { SampleViewModel(str, this) }

        // ActivityのViewModelを参照したい場合
        val viewModelOfActivity = requireActivity().getViewModel{ SampleActivityViewModel() }
    }

    // 本質外
    companion object {
        private const val ARG_SAMPLE_STR = "ARG_SAMPLE_STR"

        fun newInstance(str: String) = SampleFragment().apply {
            arguments = bundleOf(ARG_SAMPLE_STR to str)
        }
    }
}
```

## for Fragment

```kotlin:FragmentExt.kt
inline fun <reified VM : ViewModel> Fragment.getViewModel(crossinline factory: () -> VM): VM {
    return ViewModelProviders.of(this, object : ViewModelProvider.Factory {
        override fun <VM : ViewModel> create(modelClass: Class<VM>): VM {
            return requireNotNull(modelClass.cast(factory()))
        }
    }).get(VM::class.java)
}

inline fun <reified VM : ViewModel> Fragment.viewModelProvider(crossinline factory: () -> VM) = lazy {
    getViewModel { factory() }
}
```

## for FragmentActivity
上の拡張関数で生やす元がFragmentActivityになっただけ

```kotlin:FragmentActivityExt.kt
inline fun <reified VM : ViewModel> FragmentActivity.getViewModel(crossinline factory: () -> VM): VM {
    return ViewModelProviders.of(this, object : ViewModelProvider.Factory {
        override fun <VM : ViewModel> create(modelClass: Class<VM>): VM {
            return requireNotNull(modelClass.cast(factory()))
        }
    }).get(VM::class.java)
}

inline fun <reified VM : ViewModel> FragmentActivity.viewModelProvider(crossinline factory: () -> VM) = lazy {
    getViewModel { factory() }
}
```

# 解説
Fragment(とFragmentActivity)に拡張関数を生やして、ViewModelProviders.of().get()をいい感じにしてくれればゴールです。
ViewModelProviders.ofに必要なのは

* Fragment
* ViewModelProvider.Factory
クラスをもらってViewModelを返すもの
* get(ViewModelのクラス)

Fragmentはthisが使えます。
ViewModelProvider.Factoryの中身は、createを実装するもので、これはViewModelを生成して返せばゴールです。
Factoryは、引数を拡張関数は知らなくて良い(外に任せる)ので、引数無しでVMを返す高階関数で表現できます。
`factory: () -> VM`
getにはクラスを入れる必要があります。
拡張関数の引数でもらってきて入れるのが簡単ですが、VMはViewModelを継承したクラスと分かっているので、VM::class.javaができればクラスを引数に取る必要はありません。
そこで `reified`の登場です。
### reified
3行でまとめると
> reified type paramter = 具象化された型パラメータ
→reifiedを使うことで、T::class.javaを実現できる
→reifiedを使うには、inline関数である必要がある

公式サイトや太郎さんの記事が参考になります。

[公式サイト](https://kotlinlang.org/docs/reference/inline-functions.html#reified-type-parameters)
[日本語](https://dogwood008.github.io/kotlin-web-site-ja/docs/reference/inline-functions.html#%E5%85%B7%E4%BD%93%E5%8C%96%E5%9E%8B%E3%83%91%E3%83%A9%E3%83%A1%E3%83%BC%E3%82%BF-reified-type-parameters)
[太郎さんのサイト](https://taro.hatenablog.jp/entry/2015/01/29/223239)

reifiedを使えば良いですが、このためにはinline関数にする必要があります。
ただ、crossinlineをつけないとfactory: () -> VMがcreate内から参照できません。

### crossinline
まとめると
> inline関数では、渡されてラムダを関数本体から直接ではなく、
ローカルオブジェクトやネストされた関数などの別の実行コンテキストから呼び出すことは許可されていない
→ラムダパラメータにcrossinlineをつけることで可能になる

詳しくは公式サイトのreifiedの上に載っています。

`requireNotNull(modelClass.cast(factory()))`
は警告回避のために行っています。
as TのUNCHECKED_CASTの回避のために `modelClass.cast(factory())`
NULLABILITY_MISMATCH_BASED_ON_JAVA_ANNOTATIONSの回避のために `requireNotNull`


以上を組み合わせることで拡張関数を実現しています。
調べていたとき、reifiedが便利すぎて感動しました。
T::class.javaが出来るなんてジェネリクス好き歓喜。

# 道行き
結論に至るまでの道のりを備忘録がてら記載。

## ViewModelProvidersの利用

通常、AACのViewModelを取得するためには、ViewModelProviders.ofを利用します。

```kotlin
// 引数がない場合
ViewModelProviders.of(Fragment).get(SampleViewModel::class.java)
// 引数が必要な場合
ViewModelProviders.of(Fragment, SampleViewModelFactory(arg1, arg2)).get(SampleViewModel::class.java)
```

多くの場合、引数が必要な場合はViewModelクラスと対になるFactoryClassを作ります。

```SampleViewModelFactory.kt
class SampleViewModelFactory(arg1: String, arg2: Int) : ViewModelProvider.Factory {

    override fun <T : ViewModel?> create(modelClass: Class<T>): T {
        if (modelClass != SampleViewModel.class.java) {
            throw IllegalArgumentException("ViewModel class is not SampleViewModel")
        }
        return TextToSpeechDemoViewModel(arg1, arg2) as T
    }
}
```

## Util化
毎回クラスを作るのは面倒です。
引数を見てみると、必要なのはViewModelProder.Factoryとなっています。
Factoryクラスを作るときに、実装しましたね。要はこれがあればよいのです。
![image.png](https://qiita-image-store.s3.amazonaws.com/0/192408/c8cb49e9-ae8a-3724-569a-586607aac995.png)
[リファレンス](https://developer.android.com/reference/android/arch/lifecycle/ViewModelProviders#public-constructors)

Factoryの中にはcreateメソッドがあり、中を見てみるとクラスをもらって引数を利用してViewModelを生成し、Tにキャストして返しています。
ViewModelによって必要な引数はバラバラです。
なのでViewModelを生成する処理は引数にとり外に任せることにしましょう。
ViewModelを生成する処理を高階関数 `() -> T`として引数に渡せば、生成ロジックを外に任せることができます。
これでUtilクラスで汎用的にできそうです。

```kotlin:ViewModelProvidersUtils.kt
// 引数がない場合の生成メソッド
fun <T : ViewModel> create(fragment: Fragment, clazz: Class<out T>): T {
    return ViewModelProviders.of(fragment, object : ViewModelProvider.Factory {
        override fun <T : ViewModel> create(modelClass: Class<T>): T {
            return clazz.newInstance() as T
        }
    }).get(clazz)
}


// 引数がある場合の生成メソッド
fun <T : ViewModel> create(fragment: Fragment, clazz: Class<out T>, factory: () -> T): T {
    return ViewModelProviders.of(fragment, object : ViewModelProvider.Factory {
        override fun <T : ViewModel> create(modelClass: Class<T>): T {
            return factory() as T
        }
    }).get(clazz)
}
```
使う側

```kotlin
// 引数なし
val vm = ViewModelProvidersUtils.createViewModel(SampleViewModel::class.java)
// 引数あり
val vm = ViewModelProvidersUtils.createViewModel(SampleViewModel::class.java) {
    SampleViewModel(arg1, arg2)
}
```

Utilの2つのメソッドの実装をよく見ると、ほとんど同じ処理をしています。
引数一つの `createViewModel`は、引数二つの `createViewModel`の `factory() as T`に当たる部分で`clazz.newInstance()`をしていますね。
kotlinはデフォルト引数が使えるので一つにできます。

```kotlin:ViewModelProvidersUtils.kt
fun <T : ViewModel> create(fragment: Fragment, clazz: Class<out T>, factory: () -> T = { clazz.newInstance() as T }): T {
    return ViewModelProviders.of(fragment, object : ViewModelProvider.Factory {
        override fun <T : ViewModel> create(modelClass: Class<T>): T {
            return factory() as T
        }
    }).get(clazz)
}
```
これで、 
`第二引数を指定しない場合はclazz.newInstance()が行われる`
`指定すれば引数ありの場合に対応できる`
ようになりました。


## 拡張関数化
必ずFragmentから呼ぶもので、汎用的に使えそうなので拡張関数にしてみましょう。

```kotlin:FragmentExt.kt
fun <T : ViewModel> Fragment.createViewModel(clazz: Class<out T>, factory: () -> T = { clazz.newInstance() as T }): T {
    return ViewModelProviders.of(this, object : ViewModelProvider.Factory {
        override fun <T : ViewModel> create(modelClass: Class<T>): T {
            return factory() as T
        }
    }).get(clazz)
}
```

使う側

```kotlin:Fragment内からの呼び出し
// 引数なし
val vm = createViewModel(SampleViewModel::class.java)
// 引数あり
val vm = createViewModel(SampleViewModel::class.java) {
    SampleViewModel(arg1, arg2)
}
```

ここで拡張関数を見てみると、(人間的には)返す型がTと決まっているので、クラスを引数に渡すのは無駄じゃない？と思います。
.get(clazz)のところをT::class.javaとできれば、clazz: Class<out T>を無くせそうです。
そこで、reifiedが登場し、最終形になります。
[`解説`へと続くわけです](#解説)