Flutterの公式ドキュメントを読んで理解する 〜State management〜

# 読んだページ
https://flutter.dev/docs/development/data-and-backend/state-mgmt/intro

# 個人的なまとめ
* Widgetに変更があるとき、Widget自体を変更するのではなく、変更が適用されたWidgetで置き換わる。
* なので、Widget自体は不変であり、置き換わるものである。
* 他のWidgetからアクセスする必要がない状態を扱う際は`StatefulWidget`を使う。
* それ以外の場合は、`StatefulWidget`を使っても良いし、`provider`パッケージを使っても良い(`provider`が主流らしい)
* `ChangeNotifier`を拡張してモデルを作り、`notifyListeners()`で変更を通知する。
* `ChangeNotifierProvider`を使って、`ChangeNotifier`を通知したいWidgetに渡す。
* `ChangeNotifier`のモデルにアクセスしたいときは、`Consumer<ModelName>`を使う。
* `Consumer`widgetはなるべく深いところに置く。(再ビルドの範囲を小さくするため)

# State management
## Introduction
リアクティブアプリの状態管理について既に詳しい場合は、
[様々なアプローチのリスト](https://flutter.dev/docs/development/data-and-backend/state-mgmt/options)を確認したいかもしれませんが、このセクションをスキップすることができます。

<img src="https://flutter.dev/assets/development/data-and-backend/state-mgmt/state-management-explainer-5495afe6c3d6162f145107fe45794583bc4f2b55be377c76a92ab210be74c033.gif" />

Flutterを探っていると、アプリ全体を通して、画面間でアプリの状態を共有する必要があるときがあります。そこには多くのアプローチと考えるべき多くの質問があります。

以降のページでは、Flutterアプリにおける状態の扱い方の基礎を学ぶことができます。

## Start thinking declaratively
(Android SDKやiOS UIKitのような)命令的フレームワークからFlutterに来ている場合は、
アプリ開発について新しい視点から考える必要があります。

多くの仮定はFlutterには当てはまりません。
例えば、FlutterではUIの一部を変更する代わりに、最初から再構築しても問題ありません。
Flutterは必要に応じてすべてのフレームでさえ、十分な速度です。

Flutterは宣言的です。
つまり、アプリの現在の状態を反映したUIを構築します：

<img src="https://flutter.dev/assets/development/data-and-backend/state-mgmt/ui-equals-function-of-state-54b01b000694caf9da439bd3f774ef22b00e92a62d3b2ade4f2e95c8555b8ca7.png" />

アプリの状態が変わるとき(例えば、設定画面でユーザーがスイッチを切り替えると)、状態が変わり、UIの再描画をトリガーします。
`widget.setText`のように、UI自身には命令的な変更はありません。
状態を変更すると、UIは最初から再構築されます。

[スタートガイド](https://flutter.dev/docs/get-started/flutter-for/declarative)でUIプログラミングの宣言的なアプローチの詳細を見てください。

UIプログラミングの宣言的なスタイルにはたくさんのメリットがあります。
驚くべきことに、UIの任意の状態に対して、コードパスは1つしかありません。

最初は、このプログラミングスタイルは命令的スタイルほど直感的ではないように思えるかもしれません。
これがこのセクションがここにある理由です。

## Differentiate between ephemeral state and app state
このドキュメントでは、アプリの状態、短命な状態、Flutterでそれぞれをどう管理するかを紹介しています。

可能な限り広い意味で、アプリの状態はアプリの実行中にメモリに存在するあらゆるものです。
これは、FlutterフレームワークがUIやアニメーションの状態、テクスチャ、フォントなどに関して保持しているアセットやすべての変数を含みます。
この可能な限り広い状態の定義は有効ですが、アプリの設計には役立ちません。

まず、一部の状態(テクスチャなど)さえ管理する必要はありません。
フレームワークが処理してくれます。
そのため、状態のより役に立つ定義は、「UIをいつでも再構築するために必要なすべてのデータ」です。
次に、自分で管理する必要がある状態は、2つの概念的タイプ、一時的な状態とアプリの状態にわけることができます。

### Ephemeral state
一時的な状態(UIの状態またはローカル状態と呼ばれることもある)は1つのWidgetにきれいに含めることができる状態です。

これは意図的に曖昧な定義であるため、ここにいくつかの例を示します。

* `PageView`の現在のページ
* 複雑なアニメーションの現在の進行度
* `BottomNavigationBar`の現在の選択されたタブ

Widgetツリーのほかの部分は、このような状態にアクセスする必要はほとんどありません。
シリアル化する必要はなく、複雑な方法で変更されることもありません。

つまり、このような状態において状態管理技術(ScopedModel, Reduxなど)を使う必要はありません。
必要なものは`StatefulWidget`だけです。

以下では、Bottom Navigation Barの現在選択されているアイテムが、どのように`_MyHomepageState`の`_index`フィールドで保持されるかを示しています。
この例では、`_index`が一時的な状態です。

```dart
class MyHomepage extends StatefulWidget {
  @override
  _MyHomepageState createState() => _MyHomepageState();
}

class _MyHomepageState extends State<MyHomepage> {
  int _index = 0;

  @override
  Widget build(BuildContext context) {
    return BottomNavigationBar(
      currentIndex: _index,
      onTap: (newIndex) {
        setState(() {
          _index = newIndex;
        });
      },
      // ... items ...
    );
  }
}
```
ここでは、`setState()`と`StatefulWidget`の`State`クラスの中でのfieldの使用は完全に自然です。
アプリの他の部分で`_index`にアクセスする必要はありません。
さらに、ユーザーがアプリを閉じてアプリを再起動した場合も、`_index`がゼロにリセットされても問題ありません。

### App State
一時的でない状態、つまり、アプリの多くの部分を通して共有する必要のある状態、または、ユーザーのセッション間で維持したい状態は、アプリの状態と呼ぶものです(共有された状態と呼ばれることもあります)。

アプリの状態の例です：

* ユーザー設定
* ログイン情報
* ソーシャルネットワーキングアプリでの通知
* ECアプリでのカート
* ニュースアプリでの既読/未読の状態

アプリの状態を管理するには、選択肢を調査する必要があります。
どれを選ぶかはアプリの複雑さと性質、チームの以前の経験や他の多くの側面によります。

### There is no clear-cut rule
わかりやすくするために、アプリですべての状態を`State`と`setState()`で管理することができます。
実は、Flutterチームは多くの簡単なアプリサンプルでこうしています(`flutter create`で作られるスターターアプリも含む)。

逆もまた然りです。
例えば、特定のアプリのコンテキストにおいて、BottomNavigationBarの選択されているタブは一時的でない状態であると決定しても良いのです。
クラスの外から変更したり、セッション間で保持したりするなどの必要があるかもしれません。
その場合は、`_index`変数はアプリの状態です。

ある特定の変数が一時的な状態かアプリの状態かどうかを区別する明確で普遍的なルールはありません。
ある方をもう一方にリファクタリングする必要があることもあります。
例えば、明らかに一時的な状態でスタートしますが、アプリの機能が大きくなり、アプリの状態に移行する必要があるかもしれません。

そのためには、次の図を話半分に見てください: 

<img src="https://flutter.dev/assets/development/data-and-backend/state-mgmt/ephemeral-vs-app-state-3137024aa509b4df5d20ed7ed30fb8a0f7cff54ebc8ab0d6e39794bced87e27c.png" />

ReactのsetState vs Reduxのstoreについて聞かれた時、Reduxの製作者であるDan Abramovはこう答えました: 
「経験則としては、扱いにくいものは何でもしてください。」

>絶対どっちを使うとかではなく、やってみてだめだったらもう片方も使ってみようぜ、みたいなことか・・・？

要約すると、Flutterには2つの概念的なタイプの状態があります。
一時的な状態は、`State`と`setState()`を使って実装することができ、多くの場合は1つのWidgetに配置されます。
残りはアプリの状態です。
どちらのタイプもどのFlutterアプリにも使われ、2つのタイプの違いはユーザーの好みとアプリの複雑さによって異なります。

## Simple app state management
宣言的UIプログラミングと、一時的な状態とアプリの状態の違いについて知り、簡単なアプリの状態管理について学習する準備ができました。

このページでは、`provider`パッケージを使います。
Flutterを初めて使う場合や他のアプローチ(Redux,Rx,hooksなど)を使う強い理由がなければ、これはおそらく最初に使うべきアプローチです。
`provider`パッケージはわかりやすく、多くのコードを使いません。
また、他のすべてのアプローチに適用できる概念を使用しています。

そうは言うものの、他のリアクティブフレームワークからの状態管理での強い背景がある場合は、[選択肢のページ](https://flutter.dev/docs/development/data-and-backend/state-mgmt/options)にリストされているパッケージとチュートリアルを探すこともできます。

### Our example
<img src="https://flutter.dev/assets/development/data-and-backend/state-mgmt/model-shopper-screencast-e0ada0e83cd8e7fdcad84167b8f7ffd7eb5ef85b0cb8957f03c6f05bd16b1cea.gif" />

説明のために、次のような簡単なアプリを考えてみましょう。

アプリは2つの画面を持っています：カタログとカート(それぞれ`MyCatalog`と`MyCart`widgetで表されます)。
ショッピングアプリかもしれませんが、簡単なソーシャルネットワーキングアプリと同じ構造を想像することができます(カタログを"ウォール"に、カートを"お気に入り"に入れ替える)。

>知らなかったので補足：
ウォールとは、Facebook上でユーザーが投稿を行うことができるページのことである。
[ウォールとは (Wall)： - IT用語辞典バイナリ](https://www.sophia-it.com/content/%E3%82%A6%E3%82%A9%E3%83%BC%E3%83%AB)

カタログ画面はカスタムアプリバー(`MyAppBar`)と多くのリストアイテムのスクローリングビュー(`MyListItems`)を含んでいる。

これが、Widgetツリーで視覚化されたアプリです。

<img src="https://flutter.dev/assets/development/data-and-backend/state-mgmt/simple-widget-tree-0731408a48dff242cc0ea9b8203bd9a6e0d6f1be0bb158e095ea99212fe8e727.png" />

少なくとも5つのWidgetのサブクラスがあります。
それらの多くは、他の場所に「属している」状態にアクセスする必要があります。
例えば、各`MyListItem`はカートに自身を追加することができる必要があります。
現在表示されているアイテムが既にカートにあるかどうかも見たいかもしれません。

Flutterでは、状態を使うWidgetの上で、その状態を管理することは理にかなっています。

なぜでしょう？
Flutterのような宣言的なフレームワークでは、UIを変えたい場合、UIを再構築する必要があります。
`MyCart.updateWith(somethingNew)`を持つ簡単な方法はありません。
つまり、widgetの関数を呼び出して、外側から命令的にwidgetを変更することは難しいのです。
そしてこれができたとしても、役立つものではなく、フレームワークと戦っていることになります。

```dart
// BAD: DO NOT DO THIS
void myTapHandler() {
  var cartWidget = somehowGetMyCartWidget();
  cartWidget.updateWith(item);
}
```
上記のコードが機能したとしても、`MyCart`widgetで以下の対処をしなくてはならないでしょう。

```dart
// BAD: DO NOT DO THIS
Widget build(BuildContext context) {
  return SomeWidget(
    // The initial state of the cart.
  );
}

void updateWith(Item item) {
  // なんとかしてここからUIを変更する必要があります。
}
```
UIの現在の状態を考慮して、新しいデータを適用する必要があります。
このやり方でバグを回避するのは困難です。

Flutterでは、コンテンツが変わるたびに新しいWidgetを作成します。
`MyCart.updateWith(somethingNew)`(関数呼び出し)の代わりに、`MyCart(contents)`(コンストラクタ)を使います。
親Widgetのビルド関数でのみ新しいWidgetを構築することができるため、コンテンツを変更したい場合は、それは`MyCart`の親かそれ以上のところにある必要があります。

```dart
// GOOD
void myTapHandler(BuildContext context) {
  var cartModel = somehowGetMyCartModel(context);
  cartModel.add(item);
}
```
`MyCart`には、UIの任意のバージョンを構築するためのコードパスが1つだけあります。

```dart
// GOOD
Widget build(BuildContext context) {
  var cartModel = somehowGetMyCartModel(context);
  return SomeWidget(
    // カートの現在の状態を使用して、UIを一度構築するだけです。
    // ···
  );
}
```
この例では、`contents`は`MyApp`にある必要があります。
それが変更されるたびに、上から`MyCart`が再構築されます(詳細は後ほど)。
このおかげで、`MyCart`はライフサイクルについて気にする必要がなくなります。
それは、与えられた`contents`に対して何を表示するかを宣言するだけです。
それが変わった時は、古い`MyCart`widgetが消え、完全に新しいものと置き換わります。

<img src="https://flutter.dev/assets/development/data-and-backend/state-mgmt/simple-widget-tree-with-cart-996ab650c5ec3ead51e8e731b6ba7c3b1c2a07c511b78b24be844dc71b5afb92.png" />

これが、Widgetが不変であると言う意味です。
Widgetは変更されません、置き換わるのです。

カートの状態をどこに置くかわかったので、それにアクセスする方法を見てみましょう。

### Accessing the state
ユーザーがカタログのアイテムの1つをクリックすると、それはカートに追加されます。
カートは`MyListItem`の上にありますが、どうやるのでしょうか？

簡単な選択肢は、クリックしたときに`MyListItem`が呼び出せるコールバックを提供することです。
Dartの関数はファーストクラスオブジェクトなので、やりたいようにそれらを渡すことができます。
したがって、`MyCatalog`の中で以下のように定義できます: 

```dart
@override
Widget build(BuildContext context) {
  return SomeWidget(
    // Construct the widget, passing it a reference to the method above.
    MyListItem(myTapCallback),
  );
}

void myTapCallback(Item item) {
  print('user tapped on $item');
}
```
これは正常に動きますが、多くの場所で変更する必要があるアプリの状態のために、多くのコールバックを渡す必要があります。
幸いなことに、FlutterにはWidgetが子孫(つまり、子供だけでなく、下にあるどのWidgetにも)にデータとサービスを提供する仕組みがあります。
すべてがWidgetであるFlutterに期待する通り、これらの仕組みは特別な種類のWidgets(`InheritedWidget`,`InheritedNotifier`,`InheritedMode`など)です。
それらはここでやろうとしていることに対して少し例レベルであるため、ここでは取りあげません。

代わりに、低レベルのWidgetで動作するが簡単に使えるパッケージを使います。
それは`provider`と呼びます。

`provider`を使うと、コールバックや`InheritedWidgets`を考慮する必要がなくなります。
しかし、3つの概念を理解する必要があります:
 
* ChangeNotifier
* ChangeNotifierProvider
* Consumer

### ChangeNotifier
`ChangeNotifier`はFlutter SDKに含まれる簡単なクラスで、リスナーに変更を通知します。
つまり、何かが`ChangeNotifier`である場合、その変更をサブスクライブできます。
(用語に精通している人にとっては、これはObservableです。)

`provider`では、`ChangeNotifier`はアプリの状態をカプセル化する1つの方法です。
非常にシンプルなアプリの場合、1つの`ChangeNotifier`で済みます。
複雑なアプリの場合、いくつかのモデルがあるため、いくつかの`ChangeNotifier`を使います。
(`provider`で`ChangeNotifier`を使う必要は全くありませんが、簡単に操作できるクラスです。)

ショッピングアプリの例では、`ChangeNotifier`でカートの状態を管理したいと思います。
それを拡張する新しいクラスを作ります：

```dart
class CartModel extends ChangeNotifier {
  // 内部的、プライベートなカートの状態
  final List<Item> _items = [];

  // カートのアイテムの変更不可なView
  UnmodifiableListView<Item> get items => UnmodifiableListView(_items);

  // (すべてのアイテムが$42としたときの)すべてのアイテムの現在の合計金額
  int get totalPrice => _items.length * 42;

  // [item]をカートに追加します。これと[removeAll]は外側からカートを変更する唯一の方法です。
  void add(Item item) {
    _items.add(item);
    // この呼び出しは、WidgetにこのモデルをリッスンしているWidgetに再構築を指示します。
    notifyListeners();
  }

  /// カートからすべてのアイテムを消します。
  void removeAll() {
    _items.clear();
    // この呼び出しは、WidgetにこのモデルをリッスンしているWidgetに再構築を指示します。
    notifyListeners();
  }
}
```
`ChangeNotifier`特有の唯一のコードは、`notifyListeners()`の呼び出しです。
アプリのUIを変更する可能性のある方法でモデルが変更されるたびに、この関数を呼び出します。
`CartModel`のその他すべては、モデル自身とビジネスロジックである。

`ChangeNotifier`は`flutter:foundation`の一部であり、Flutterのどの上位のクラスにも依存しません。
簡単にテストできます([widget testing](https://flutter.dev/docs/testing#widget-tests)を使う必要さえありません。)。
例えば、これが`CartModel`の簡単なユニットテストです:

```dart
test('adding item increases total cost', () {
  final cart = CartModel();
  final startingPrice = cart.totalPrice;
  cart.addListener(() {
    expect(cart.totalPrice, greaterThan(startingPrice));
  });
  cart.add(Item('Dash'));
});
```

### ChangeNotifierProvider
`ChangeNotifierProvider`は`ChangeNotifier`のインスタンスをその子孫に提供するWidgetです。
`provider`パッケージから取得されます。

`ChangeNotifierProvider`をどこに置くか既に知っています、それにアクセスする必要があるWidgetの上です。
`CartModel`の場合は、`MyCart`と`MyCatalog`の上のどこかを意味します。

`ChangeNotifierProvider`を(スコープを汚したくないため)必要以上に高階層に置きたくはないでしょう。
しかしこの場合、`MyCart`と`MyCatalog`の両方の上のWidgetは`MyApp`しかありません。

```dart
void main() {
  runApp(
    ChangeNotifierProvider(
      create: (context) => CartModel(),
      child: MyApp(),
    ),
  );
}
```
`CartModel`の新しいインスタンスを作るbuilderを定義していることに注意してください。
`ChangeNotifierProvider`は絶対に必要な場合を除いて、`CartModel`を再構築しないほど十分にスマートです。
インスタンスがこれ以上必要ない場合は、自動で`CartModel`の`dispose()`を呼びます。

複数のクラスを提供する場合は、`MultiProvider`を使うことができます:

```dart
void main() {
  runApp(
    MultiProvider(
      providers: [
        ChangeNotifierProvider(create: (context) => CartModel()),
        Provider(create: (context) => SomeOtherClass()),
      ],
      child: MyApp(),
    ),
  );
}
```

### Consumer
最上部の`ChangeNotifierProvider`の宣言を通して、`CartModel`がアプリに提供されるようになったため、それを使い始めることができます。

これは`Consumer`widgetを通して行われます。

```dart
return Consumer<CartModel>(
  builder: (context, cart, child) {
    return Text("Total price: ${cart.totalPrice}");
  },
);
```

アクセスしたいモデルの型を指定する必要があります。
この場合ｈ、`CartModel`にアクセスしたいので、`Consumer<CartModel>`と書きます。
ジェネリック(`<CartModel>`)を指定しない場合、`provider`パッケージは役に立ちません。
`provider`は型に基づいており、型がなければ何が必要なのかわかりません。

`Consumer`widgetに唯一必要な引数はbuilderです。
Builderは`ChangeNotifier`が変化するたびに呼ばれる関数です(つまり、モデルで`notifyListeners()`を呼び出す時、すべての対応する`Consumer`widgetのbuilderメソッドが呼ばれます)。

builderは3つの引数を指定して呼び出します。
1つ目は`context`です、すべてのbuildメソッドでも取得します。

builderメソッドの2つ目の引数は、`ChangeNotifier`のインスタンスです。
それは、最初に求めていたものです。
モデルのデータを使用して、任意の時点でのUIの外観を定義することができます。

3つ目の引数は`child`で、最適化のためにあります。
モデルが変わっても変化しないような大きなWidgetサブツリーが`Consumer`の下にある場合、一度それを構築して、builderを通してそれを取得できます。

```dart
return Consumer<CartModel>(
  builder: (context, cart, child) => Stack(
        children: [
          // 毎回再構築せずに、SomeExpensiveWidgetをここで使用します。
          child,
          Text("Total price: ${cart.totalPrice}"),
        ],
      ),
  // コストが高いWidgetをここでビルドします
  child: SomeExpensiveWidget(),
);
```
できるだけツリーの深くに`Consumer`widgetを置くことがベストプラクティスです。
一部の詳細がどこかで変更されただけで、UIの大部分を再構築したくないでしょう。

```dart
// DON'T DO THIS
return Consumer<CartModel>(
  builder: (context, cart, child) {
    return HumongousWidget(
      // ...
      child: AnotherMonstrousWidget(
        // ...
        child: Text('Total price: ${cart.totalPrice}'),
      ),
    );
  },
);
```
代わりに: 

```dart
// DO THIS
return HumongousWidget(
  // ...
  child: AnotherMonstrousWidget(
    // ...
    child: Consumer<CartModel>(
      builder: (context, cart, child) {
        return Text('Total price: ${cart.totalPrice}');
      },
    ),
  ),
);
```

### Provider.of
場合によっては、UIを変更するためにモデル内のデータは実際には必要ありませんが、それでもアクセスする必要はあります。
例えば、`ClearCart`ボタンによって、ユーザーがカートからすべてのものを削除することができるようにしたいです。
カートの内容を表示する必要はなく、`clear()`関数を呼ぶことだけ必要です。

これに対しては、`Consumer<CartModel>`が使えますが、無駄があります。
再構築する必要のないWidgetに再構築するようにフレームワークに依頼しています。

この使用例では、`listen`パラメータを`false`にセットした`Provider.of`を使うことができます。

```dart
Provider.of<CartModel>(context, listen: false).removeAll();
```
上記のコードをbuild関数内で使っても、`notifyListeners()`が呼ばれた時このWidgetは再構築をしません。

### Putting it all together
この記事でカバーされている[例をチェックアウト](https://github.com/flutter/samples/tree/master/provider_shopper)することができます。
よりシンプルなものが必要であれば、[providerで構築された簡単なカウンターアプリ](https://github.com/flutter/samples/tree/master/provider_counter)を見てください。

自分で`provider`を使う準備ができたら、まず、`pubspec.yaml`にdependencyを追加するのを忘れないでください。

```yaml
name: my_name
description: Blah blah blah.

# ...

dependencies:
  flutter:
    sdk: flutter

  provider: ^3.0.0

dev_dependencies:
  # ...
```
これで、`import 'package:provider/provider.dart';`が使え、ビルドを始められます。