Jetpack ComposeでViewModelを使わずに、Composable関数を使って状態とロジックを切り出す!

## はじめに
最近、Androidアプリ開発においてJetpack Composeを使用する機会が増えたことを嬉しく感じています。

この記事では、**Jetpack Compose** で、 **ViewModelを使わないで** に **Composable関数(Factory Function)** を使って、**状態とロジック** をViewの外に切り出す方法 について、説明しています。

**Composable関数(Factory Function)** を使えば **「状態やロジック」** を簡単にViewの外に切り出すことができます。

つまり、 **「ロジックの抽出と再利用」** ができるようになるということです。

### ロジックの抽出と再利用について

**「ロジックの抽出と再利用」** は、なぜするのか。

「ロジックの抽出と再利用」が必要な理由は、
**複雑に肥大化したコンポーネント** を、小分けにして **関心事で分別** し、クリーンな状態に整理するためです。

近年、**宣言的UI** を使用して大規模なプロジェクトを構築することが増えました。

肥大化してメンテしにくいコンポーネントを目の当たりにして、我々エンジニアが苦しむことも増えました。

肥大化したコンポーネントのコードは、依存関係が複雑で量も多く、コードを読むこと自体難しくなります。

![68747470733a2f2f71696974612d696d6167652d73746f72652e73332e61702d6e6f727468656173742d312e616d617a6f6e6177732e636f6d2f302f39333730332f32323030363633642d643161632d346166302d356430622d6530373432313761303638652e706e67.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/93703/ee5d5abb-1dd1-0f3a-c955-f789ff65ea4d.png)

そこで、コンポーネントの中から「状態とロジック」を外に追い出して、キレイに整理することが必要になります。

![68747470733a2f2f71696974612d696d6167652d73746f72652e73332e61702d6e6f727468656173742d312e616d617a6f6e6177732e636f6d2f302f39333730332f65613365366164372d306130302d323436342d323935392d3737386566313365363232372e706e67.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/93703/3628ecc0-9b60-954d-67ec-da1c829b2b41.png)

ViewModelを使って状態とロジックを切り出すこともできますが、この記事では**ViewModelを使わないで** Composable関数として切り出す方法について取り上げます。

## Composable関数とは

**Jetpack Compose** を使いこなすには、 **Composable関数** について深く理解することが、**最も重要** です。

**Composable関数とは、「コンポーズ可能な関数のこと」です。**

Composable関数には、`@Composable` アノテーションが付けられています。
![Screen Shot 2022-08-20 at 22.31.18.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/93703/602ffbd4-d241-43ef-f077-715f1d7a8169.png)
(※↑はUIを定義するComposable関数)

**「コンポーズ可能」** とは、「Jetpack Composeの仕組み上、その関数は再Composeされたときに**並行** に **何度も** 呼び出されたり **順番があべこべ** になったり **スキップ** したり **キャンセル** するときがあるけど **大丈夫か？** 」ということです。

![Screen Shot 2022-08-22 at 10.14.23.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/93703/e39712c4-6f8f-eea5-42a3-f12d0825dd7b.png)

https://developer.android.com/jetpack/compose/lifecycle?hl=ja

### コンポーズ可能な関数について知っておくべき5つのこと

公式ドキュメントには、コンポーズ可能な関数について知っておくべきこととして、**以下の５つ** が挙げられています。

つまり、 **この仕様に耐えられる関数が「コンポーズ可能な関数」** ということです。

- コンポーズ可能な関数は **任意の順序**で実行できる。
- コンポーズ可能な関数は **並行して**実行できる。
- 再コンポーズは、可能な限り多くのコンポーズ可能な関数とラムダを **スキップ**する。
- 再コンポーズは厳密なものではなく、 **キャンセル** される場合がある。
- コンポーズ可能な関数は、アニメーションのフレームごとに **何度も実行**される場合がある。

**コンポーズ可能な関数は、高速かつ冪等で副作用のないものにすることが重要です。**

https://developer.android.com/jetpack/compose/mental-model?hl=ja#recomposition

### Composable関数にViewModelを渡すのは止めよう

補足の注意点として、 **Composable関数にViewModelを渡す実装** は、**危険** です。
ViewModelは、**Composeの世界の外** で生成されるもので、Composeとは**ライフサイクルが異なります。**
ViewModelをComposable関数に渡した場合、再Composeの処理に対応していないため、さまざまな不具合を引き起こす可能性があります。
つまり、**ViewModelは再Composeに耐えることができません。**
公式ドキュメントでも、注意を促しています。
Composable関数でUIを定義して、その**Composable関数にViewModelを渡す実装はやめたほうがよい**です。
![Screen Shot 2022-08-20 at 23.14.28.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/93703/dc8c013a-a545-1f99-b4b5-db5861b697ad.png)

https://developer.android.com/jetpack/compose/state?hl=ja#viewmodels-source-of-truth

### 2種類のComposable関数

Composable関数には、以下の**2種類**があります。

- **戻り値のない(Unitを返す)Composable関数(UI Function)**
  - **UIをCompose可能な関数として定義**するために使われる
  - 名前は、**大文字**で始める

- **オブジェクトを返すComposable関数(Factory Function)**
  - **状態やロジックや、それらをまとめたオブジェクトをCompose可能な関数として定義**するのに使われる
  - 名前は、**小文字**で始める(rememberを使ってオブジェクトを返す場合は、**頭にremember** をつけるのが公式の推奨)
  - オブジェクトを返すComposable関数のことを、APIガイドラインでは、**Factory関数**と呼んでいる。

詳細は、APIガイドラインを参照してください。

https://github.com/androidx/androidx/blob/c53c7d0b219e5142656efb564b818eb651615bf0/compose/docs/compose-api-guidelines.md

Jetpack Composeにおいて、Composable関数は  **「UIをCompose可能な関数として定義すること」"だけ"** に使用されるものかと思っている人も多いかと思いますが、 **「状態とロジックを返すCompose可能な関数として定義すること」にも使用できます。**

つまり、**React Hooksや、VueのComposition APIのようなことが可能** なのです。
(Reactで言う、useHogeHoge みたいなカスタムフックが定義できるということです)

### rememberもComposable関数

例として、Jetpack Composeで使用される、「remember」関数の中身は、Compose可能な関数として定義されています。

![Screen Shot 2022-08-20 at 16.23.55.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/93703/aebf8f15-39b4-eacd-4846-3d4a9e7ea223.png)
`@Composable`が付いている箇所が「Composable関数」です。

### UIを定義するComposable関数

通常は、以下のように **「UIをCompose可能な関数として定義すること」** に使われます。

```kotlin:CounterView.kt
@Composable
fun CounterView() {
    val count = remember { mutableStateOf(0) }

    Button(onClick = { count.value++ }) {
        Text("You clicked ${count.value} times")
    }
}
```

### 状態とロジックをカプセル化したオブジェクトを返すComposable関数

上記のViewの状態とロジックを切り出して、以下のように **「状態とロジックをCompose可能な関数」** として書くことが可能です。

**↓状態とロジックをViewの外に切り出した！！**

```kotlin:rememberCounter.kt
data class CounterState(
    val count: Int,
    val increment: () -> Unit
)

@Composable
fun rememberCounter(): CounterState {
    var count by remember { mutableStateOf(0) }
    return remember(count) {
        CounterState(
            count = count,             // 状態
            increment = { count += 1 } // ロジック
        )
    }
}
```

※この記事で書かれたコードの例は、**こう書けますよという一例**であり「この書き方が正しい」と主張するものではありません。

**Jetpack Composeの公式ドキュメントではViewModelを使う方法が**説明されており、 **それに従うのが無難** という考え方も**あり**だと思っています。

ただ、公式ドキュメントを見ても、ViewModelを使う方法ばかりが書かれているため
**「じゃあ、ViewModelを使わない場合はどう実装すればよいの？」**
という疑問をお持ちの方のために、この記事を書いています。
誰かの参考になれば幸いです。

https://twitter.com/kara_mage/status/1560846438912782336?s=20&t=DNyBo2XzFC9wHxCUTy64GQ

https://twitter.com/kara_mage/status/1560904426205851648?s=20&t=lz4dXxnelrjz7uk9tyowpg

## なぜViewModelを使わないのか?

**宣言的UIには、ViewModelを使ったアーキテクチャは合わない**、と感じているからです。

特に合わないなと思っているのは、**ViewModelにビジネスロジックを書いてしまうと、UI固有のロジックとして書かれてしまいます。** ViewModelは画面毎に生成されるものだからです。

### ViewModelにビジネスロジックを書くことについて

つまり、Viewからロジックを切り出すために、ViewModelにロジックを切り出すことは、**再利用性/変更容易性を妨げます**し、UIロジックとドメインロジックの境界線が曖昧になります。

Jetpack Composeの公式ドキュメントでも、たびたびViewModelが登場するのですが、**ViewModelにビジネスロジックを書いていて、あまりよくない実装**だなと思います。

公式ドキュメントの下記の例ですと、著者画面から **「著者をフォローする」というビジネスロジックがAuthorViewModelにfollowAuther** というメソッドに実装されているのですが、じゃあ、書籍一覧画面からも「著者をフォローする」という機能が必要になった場合、BookListViewModelにもfollowAutherメソッドを実装することになります。結果としてコピペロジックが散らばってViewModelがカオスな状況へ一歩踏み出してしまいます。

**再利用されるビジネスロジックは、ドメインレイヤにカプセル化する必要がある** と考えています。

https://twitter.com/kara_mage/status/1560857470561464321?s=20&t=lz4dXxnelrjz7uk9tyowpg

公式ドキュメントでも「followAutherは他の画面で再利用できないよ」と注意を促しているのですが、ちゃんとドキュメントを読み込んでいないと見落としがちかもしれないです。

https://twitter.com/kara_mage/status/1560858199489597440?s=20&t=JA9kEa22fwTwyzTTlZKHLg

合わないと感じているアーキテクチャを「過去に使っていたから」という理由だけで使い続けるのはよくないなと思います。

**Jetpack Compose採用のタイミングは、アーキテクチャ再考のタイミングにピッタリ**です。

考え直した結果、「まだViewModelは必要だ」となるか「ViewModelを使わなくてもいいよね」となるかは、人それぞれだと思いますので、どちらの結果になったとしてもそれはそれで良いと思います。

**もちろん既存のコードと相互運用するためにViewModelを使うのは賛成です。** (既存のコードをいきなり全部Jetpack Composeに書き換えるのは大変ですから)

**新規作成するJetpack Composeアプリにおいて、私は、ViewModelは必要ない** と考えています。(※個人の意見です)

ちなみに、**GoogleのJetpack Compose開発者で有名なJim** さんも
**「ViewModelはJetpack Composeに必要ないと思ってるよ。 削除することを推奨するよ」** とツイートしています。

https://twitter.com/JimSproch/status/1561024830786322433?s=20

> AAC ViewModel は Android 用の雑なもので、悪いパターンを増殖させる理由はないと思います。データレイヤーが適切に設計されていれば、AAC ViewModel を使う必要がないことに気づくはずです。

じゃあ、 **なぜ公式ドキュメントにViewModelを使う例が多く書かれているのか？**

Jimさん曰く、
「多くの人がすでにViewModelsに大きく依存している既存のアプリケーションを持っているので、**相互運用性/完全性のため** にdocsはそれらについて言及する必要があります」
とおっしゃっています。

https://twitter.com/JimSproch/status/1396855965509554176?s=20&t=9IN3GOWMAXKI1qAbI70nIg

つまりは、既存のアプリの**後方互換**のためにViewModelは公式Docで書かれているです。
もちろん、新規に作成する純粋なJetpack ComposeなアプリでもViewModelを使い続けるのは、一つの選択肢としてはありです。しかし、Composeの世界でViewModelを使うには注意点もあります。

また、Jimさんは、以下のようにおっしゃっています。

https://twitter.com/JimSproch/status/1397169679647444993?s=20&t=chgJOumL16GBg4QdH0IMXw

「アクティビティ内に ViewModel を持つことは問題ありませんが、純粋な Compose アプリでは、Compose が設定変更を処理できるため、おそらく不要です。 **コンポーザブル関数が ViewModel を参照することは、コンポーザブルをアプリやプラットフォームに不必要に結びつける** ことになり、非常に胡散臭いです。」

### ViewModelを使用するときの注意点

とは言っても、なんだかんだでViewModel使いたい場合もあるかと思います。

Jetpack Composeで、ViewModelを使う場合、いくつか注意点がありますので、気をつけてください。

![Screen Shot 2022-08-20 at 23.14.28.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/93703/dc8c013a-a545-1f99-b4b5-db5861b697ad.png)

https://developer.android.com/jetpack/compose/state?hl=ja#viewmodels-source-of-truth

#### Composable関数にViewModelをそのまま渡さない

ViewModelは、 **Composeの世界の外** で生成されるものであり、**Composeの世界の理からは外れた存在**です。
ViewModelは、世界の再Composeに耐えられないので、Composable関数に渡さないでください。
ViewModelで保持している状態を個別に渡してください。

ViewModelとComposeの世界を疎結合にすることが重要です。

#### ViewModelをCompositionLocalに渡さない

CompositionLocalを使うとめんどくさいバケツリレーをしなくて便利なのですが、これも上記と同じ理由でComposableな世界の理にViewModelは耐えられないので、ViewModelをそのまま渡さないでください。

### SwiftUIでもViewModelは不要?

以前、 **「SwiftUIでMVVMを採用するのは止めよう」** という記事を書きました。合わせてこちらもご覧ください。
SwiftUIとJetpack Composeには差異はありますが、宣言的UIという括りとしてはおおまかには変わらないと思っています。
※また、ここで言っているMVVMにおけるViewModelと、Android開発におけるAACのViewModelの意味も違うことは認識しています。ViewModelという言葉の捉え方は人さまざまで、誤解を生みやすい表現だということも認識しています。

https://qiita.com/karamage/items/8a9c76caff187d3eb838

## ViewModelを使わずに、Composable関数(Factory Function)を使って状態とロジックを切り出す方法

### Viewに状態とロジックが混在する問題

じゃあ、 **ViewModelを使わずに、状態とロジックを切り出すにはどうしたらよいのか？**

ここからは、カウンターアプリのコードを例に説明します。

最も単純なカウンターコンポーネントは、以下のようになります。

```kotlin
@Composable
fun CounterView() {
    val count = remember { mutableStateOf(0) }

    Button(onClick = { count.value++ }) {
        Text("You clicked ${count.value} times")
    }
}
```

![Screen Shot 2022-08-20 at 21.13.54.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/93703/87c4786e-597a-a4bd-14a2-a5fad894376b.png)

ボタンをタップするとカウントアップしていきます。

![Screen Shot 2022-08-20 at 21.15.11.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/93703/0ec66136-821a-280f-91fa-444e1f751c43.png)

Viewに、状態とロジックがべったり書かれています。

```kotlin
@Composable
fun CounterView() {
    val count = remember { mutableStateOf(0) } // 状態！！

    Button(onClick = { count.value++ }) {  // ロジック！！
        Text("You clicked ${count.value} times")
    }
}
```

上記のコードの問題点として、コンポーネントの中に **「View、状態、ロジック」が混在** しています。
![68747470733a2f2f71696974612d696d6167652d73746f72652e73332e61702d6e6f727468656173742d312e616d617a6f6e6177732e636f6d2f302f39333730332f65393237356339632d303034312d363430382d373637622d3632626332663331656166652e706e67.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/93703/c0526d86-1c16-46d0-a75e-2f93c5bb9f56.png)

**コンポーネントが肥大化すると、可読性が下がったり、メンテナンスしにくくなったり、様々な問題** を引き起こします。

![68747470733a2f2f71696974612d696d6167652d73746f72652e73332e61702d6e6f727468656173742d312e616d617a6f6e6177732e636f6d2f302f39333730332f32323030363633642d643161632d346166302d356430622d6530373432313761303638652e706e67.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/93703/ee5d5abb-1dd1-0f3a-c955-f789ff65ea4d.png)

### Factory Functionで状態とロジックをViewの外に切り出す

そこで、コンポーネントの中から「状態とロジック」を外に切り出します。
Composable関数を使って、簡単に外に切り出すことができます。

![68747470733a2f2f71696974612d696d6167652d73746f72652e73332e61702d6e6f727468656173742d312e616d617a6f6e6177732e636f6d2f302f39333730332f65613365366164372d306130302d323436342d323935392d3737386566313365363232372e706e67.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/93703/3628ecc0-9b60-954d-67ec-da1c829b2b41.png)

```kotlin:CounterView.kt
@Composable
fun CounterView() {
    val counter = rememberCounter()

    Button(onClick = { counter.increment() }) {
        Text("You clicked ${counter.count} times")
    }

}
```

**↓状態とロジックをViewの外に切り出した！！**

```kotlin:rememberCounter.kt
data class CounterState(
    val count: Int,
    val increment: () -> Unit
)

@Composable
fun rememberCounter(): CounterState {
    var count by remember { mutableStateOf(0) }
    return remember(count) {
        CounterState(
            count = count,             // 状態
            increment = { count += 1 } // ロジック
        )
    }
}
```

rememberを使って状態とロジックを含むCounterStateを返すComposable関数として、rememberCounterに状態とロジックを切り出すことができました。

このようにComposable関数として状態とロジックを切り出すことによって、**純粋なComposeの世界の中だけで実装が完結する** のがこのやり方のメリットです。

ViewModelを使用するとComposeの世界の中と外を意識せねばならず、その境界線を跨ぐときに注意が必要なので、なるべく境界線を意識しない方法が良いと私は考えます。

### rememberについて

rememberに慣れていないと、rememberCounter関数がやっていることは、一見魔法のように見えますが、中身を見てみると、内部のキャッシュにオブジェクトをキーと一緒に突っ込んでいます。再コンポーズ時にはそのキャッシュから値が復元されます。

ただし、画面回転時、rememberで保持した状態は消えてしまいます。
(大外のActivityごとComposeが削除される)

#### 画面回転時に、ViewModelを使わずに状態を復元したい場合
rememberの代わりに **rememberSaveable** することで、画面回転時にも状態を復元できます。
※rememberSaveableはParcelableしか保存できないのでオブジェクトを保存したい場合、Parcelableにシリアライズする必要があります。(もっと簡単にしてほしい…今後に期待)

https://developer.android.com/jetpack/compose/state?hl=ja#state-in-composables

https://zenn.dev/wada811/scraps/1b17e93b7d6575

https://twitter.com/kara_mage/status/1560892259075207169?s=20&t=13XK5oK0s9OIDgLI6yPvkg

rememberは奥が深いので、今後また別の記事で説明できたらなと思います。

## まとめ
- Jetpack Composeを使いこなすには、Composable関数について深く理解することが、最も重要
- Composable関数は、コンポーズ可能な仕様を満たす関数のこと
- Composable関数には、2種類ある。
  - UI Function(return Unit)
  - Factory Function(return value or object)
- Fuctory Functionを使って、状態とロジックをViewの外に切り出せる
- View/状態/ロジックが混在したコンポーネントは、すぐに肥大化して複雑になる。
- 状態とロジックは、こまめにダンボールに梱包して、Viewの外に切り出すとよい。
- **まだまだViewModelを使わないやり方については、情報が少ない** ので、詰まったときに自分で道を切り開くチカラが必要になる。
- 公式DocでViewModelを使用したコードを載せているのは、既存のアプリの後方互換性のために書いている
- 新規Jetpack ComposeアプリではViewModelは必要ないと、GoogleのJetpack Compose開発者のJimさんもツイートしている 
- しかしながら、**公式Docには、ViewModelを使用した例が多い**ので、それに従うのが **もっとも無難**かもしれない。(既存のコードの後方互換のためにViewModelを使っていくのが無難。ゆくゆくはPureなComposeな世界にはViewModelは必要ないのでViewModelは使わないようにしていく方針が良さそう)
- **Composable関数やrememberの使い方を深く知ることは、Jetpack Composeを使いこなす上で重要** (大事なことなのでもう一度)

## 参考

https://developer.android.com/jetpack/compose/mental-model?hl=ja#recomposition

https://developer.android.google.cn/jetpack/compose/state?hl=ja

https://developer.android.com/jetpack/compose/lifecycle?hl=ja

https://github.com/androidx/androidx/blob/c53c7d0b219e5142656efb564b818eb651615bf0/compose/docs/compose-api-guidelines.md

https://developer.android.com/jetpack/compose/libraries?hl=ja#viewmodel