【React】Concurrent Modeでインターフェースプレビューを実装してみた

<h2>はじめに</h2>
<p>都内の企業でモバイルアプリ開発を行っているすずきと申します。早いもので、エンジニアになって半年経ちました。</p>
<p>最近、開発アプリのある画面でAPIから最新のデータを都度取得するような実装を行いました。データ取得中の画面として以下のようなインジケータを追加したのですが、テストで何度か挙動を確認したところ、画面遷移のたびに表示されて軽くストレスを感じました。</p>
<p>UXの質が落ちてるな...と感じたので、YouTubeアプリみたいな感じで画面遷移中も前の画面を残す(インターフェースプレビュー)ようにできないかなぁと調べたのですが、Reactの性質上、そのような実装は難しいということがわかりました。</p>
<p>Reactにも弱点はあるんだな...と思いながらReactの公式ドキュメントを眺めていたところ、Concurrent Modeというページをふとみつけました。</p>
<div align="center">
<img width="400" alt="スクリーンショット 2021-01-24 15.35.20.png" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/569054/1e6421bb-034a-80c3-1125-2e42b59ecdb2.png">
<img width="185" alt="image.png" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/569054/186a13c7-be83-275e-5bb6-67376fc1e787.png">
</div>

<h2>Concurrent Mode(並列モード)</h2>
<p><a href="https://ja.reactjs.org/docs/concurrent-mode-intro.html">公式Docs</a>を読みすすめてみると、どうやらConcurrent Modeを使うとReactで中断可能なレンダリングが可能になるとのことでした。</p>
<p>更新のレンダーを一度始めたら中断することはできませんよ！というのが、ReactのようなUIライブラリの動作の基本だったのですが、Concurrent Modeだと中断できるようになったということですね。</p>
<p>前の画面を描画させながら、更新後の画面のレンダーをメモリ内で継続し、データが到着するごとに再レンダーを行うことができるので、この仕組みを利用することで、前の画面を表示したまま、インジケータをインライン表示するよう React に伝えることができます。新しい画面の準備が完了したら、React が自動的にそちらを表示します。</p>

<h2>SuspenseとuseTransition</h2>
<p>Concurrent Modeでインターフェースプレビューを実現するためにキーワードとなるのが、SuspenseとuseTransitionです。</p>
<h3>Suspense</h3>
<p>SuspenseはReact 16.6で追加されたコンポーネントです。コンポーネントが読みだそうとしているデータが準備できていないとき、宣言的にロード中の状態を指定することができるようになります。</p>
<p>Suspenseを使用する目的の1つに、RESTやGraphQLのデータ取得ライブラリとReactとの深い連携があります。データ取得ライブラリがSuspenseをサポートすることで、コンポーネントからそれを自然に扱えるようになります。Suspenseは連携するライブラリの種類を選びませんが、Facebookで本番環境として利用しているライブラリはRelayのみだそうです(Apolloでは今のところテストされていないようです...)。</p>

<h3>useTransition</h3>
<p>新しい画面に遷移する前に新しいコンテンツがロードされるのを待機するために使用するのがReact Hooksの1つであるuseTransitionです。</p>

```javascript

const [startTransition, isPending] = useTransition({
  timeoutMs: 3000
});
```
<p>startTransitionでどのstateの更新を遅延させたいのかをReactに伝え、isPendingでトランジションが進行中かどうかを伝えます。</p>
<p>timeoutMsプロパティでトランジションが終了するまでどれだけ待てるかを指定します。例えば、{timeoutMs: 3000}で、「新しい画面がロードされるのに3秒以上かかったら大きなスピナーを表示せよ、それまでは前の画面を表示しつづけて構わない」ということを伝えています。</p>

<h2>データ取得アプローチの比較</h2>
<p>インターフェースプレビューの実装が今回の目的なのですが、勉強のためにReactのデータ取得の各種アプローチについて検証してみることにしました。公式Docsの例をベースに、Material-UIの勉強も兼ねて新しく実装しました。</p>
<p>プロフィール部分とグラフ部分がどのような順番で表示されるのかどうかを検証します。ソースは<a href="https://github.com/suzuki0430/concurrent-ui">GitHub</a>にあります。</p>
<div align="center">
<img width="800" alt="スクリーンショット 2021-01-24 21.33.01.png" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/569054/634ad607-8e81-f2ef-6430-3ba462b8da53.png">
</div>


<h3>1. Fetch-on-Render(Suspense不使用)</h3>
![ezgif.com-gif-maker.gif](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/569054/72ea1955-02bc-3dbb-c2dc-3618ae8a2bd2.gif)
<p>Reactアプリケーションのデータ取得は、classコンポーネントであればライフサイクルメソッド(component~)、functionalコンポーネントであれば副作用(effect)を用いるのが一般的です。</p>
<p>Fetch-on-Renderというのは、このようなレンダー後にデータ取得が始まるようなアプローチのことをいいます。</p>

<h6>FetchOnRender.jsx</h6>
```javascript
export const FetchOnRender = () => {
  const [userData, setUserData] = useState(null);

  useEffect(() => { // ①, ③
    fetchUserData().then((u) => setUserData(u));
  }, []);

  if (userData === null) { // ②
    return (
      <Typography variant="p" component="h7">
        Loading profile...
      </Typography>
    );
  }
  return (
    <div>
      <DetailsContent
        company={userData.data.company}
        name={userData.data.name}
        image={userData.data.image}
      />
      <ProfileChart />
    </div>
  );
};

const ProfileChart = () => {
  const [chartData, setChartData] = useState(null);

  useEffect(() => { // ④, ⑥
    fetchChartData().then((p) => setChartData(p));
  }, []);

  if (chartData === null) { // ⑤
    return (
      <Typography variant="p" component="h7">
        Loading chart...
      </Typography>
    );
  }

  return <ChartContent data={chartData} />;
};
```
<p>コードの実行順は以下のようになります。</p>
<p>①プロフィールデータ取得開始->②待機->③プロフィールデータ取得完了->④グラフデータ取得開始->⑤待機->⑥グラフデータ取得完了</p>
<p>グラフデータの取得はプロフィールデータを取得するまで開始されません。これをウォーターフォールといいます。</p>

<h3>2. Fetch-Then-Render（Suspense未使用）</h3>
![ezgif.com-gif-maker (1).gif](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/569054/bf95887e-c7e9-914f-9f64-5f6da043e36e.gif)
<p>Fetch-Then-Renderは、Fecth-on−Renderで起こったウォーターフォールを防止するために、データ取得を1つの副作用で行うアプローチのことをいいます。</p>
<h6>FetchThenRender.jsx</h6>

```javascript
const promise = fetchProfileData();

export const FetchThenRender = () => {
  const [userData, setUserData] = useState(null);
  const [chartData, setChartData] = useState(null);

  useEffect(() => { // ①, ②, ③, ④, ⑤
    promise.then((data) => {
      setUserData(data.userData);
      setChartData(data.chartData);
    });
  }, []);

  if (userData === null) {
    return (
      <Typography variant="p" component="h7">
        Loading profile...
      </Typography>
    );
  }
  return (
    <div>
      <DetailsContent
        company={userData.data.company}
        name={userData.data.name}
        image={userData.data.image}
      />
      <ProfileChart chartData={chartData} />
    </div>
  );
};

const ProfileChart = ({ chartData }) => {
  if (chartData === null) {
    return (
      <Typography variant="p" component="h7">
        Loading chart...
      </Typography>
    );
  }

  return <ChartContent data={chartData} />;
};
```
<p>コードの実行順は以下のようになります。</p>
<p>①プロフィールデータ取得開始->②グラフデータ取得開始->③待機->④プロフィールデータ取得完了->⑤グラフデータ取得完了</p>
<p>Fetch-on-Renderで発生したウォーターフォールは解決されましたが、ここでも別のウォーターフォールが発生しています。fetchProfileData内部のPromise.all()ですべてのデータが到着するまで待機しているので、グラフデータがロードされるまでプロフィール部分をレンダーすることができません。</p>
<h6>noSuspenseApi.js</h6>

```javascript
export const fetchProfileData = () => {
  return Promise.all([fetchUserData(), fetchChartData()]).then(
    ([userData, chartData]) => {
      return { userData, chartData };
    }
  );
};
```


<h3>3. Render-as-You-Fetch（Suspense使用）</h3>
![ezgif.com-gif-maker (2).gif](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/569054/383fc987-1d41-cddd-f01a-33251f5c69c3.gif)
<p>Fetch-on-RenderやFetch-then-RenderのようなSuspenseを使用しないアプローチでは、データ取得完了->レンダー開始という順番でしたが、Suspenseを使うと、このステップが入れ替わり、レンダー開始->データ取得完了という順番になります。</p>
<h6>RenderAsYouFetch.jsx</h6>

```javascript
const resource = fetchProfileData();

export const RenderAsYouFetch = () => {
  return <ProfilePage />;
};

const ProfilePage = () => {
  return (
    <Suspense
      fallback={
        <Typography variant="p" component="h7">
          Loading profile...
        </Typography>
      }
    >
      <ProfileDetails />
      <Suspense
        fallback={
          <Typography variant="p" component="h7">
            Loading chart...
          </Typography>
        }
      >
        <ProfileChart />
      </Suspense>
    </Suspense>
  );
};

const ProfileDetails = () => {
  const userData = resource.userData.read();
  return (
    <DetailsContent
      company={userData.data.company}
      name={userData.data.name}
      image={userData.data.image}
    />
  );
};

const ProfileChart = () => {
  const data = resource.chartData.read();
  return <ChartContent data={data} />;
};
```
<p>以上のコードでは、レンダー時点でfetchProfileData()をつかってリクエストがスタートしています。今回の検証ではフェイクのAPI実装を行っていますが、実際はRelayやApolloのようなデータ取得ライブラリのSuspense連携機能を使います(上述していますが、連携機能がテストされているのは今のところRelayのみです)。</p>
<p>RenderAsYouFetchのレンダーを試みます。子要素として、ProfileDetailsとProfileChartが返ります。</p>
<p>ProfileDetailsのレンダーを試みます。内部でresource.userData.read()が呼び出されます。データはまだ取得されていないので、このコンポーネントはSuspendし、ツリーの他のコンポーネントのレンダーを試みます。</p>
<p>ProfileChartのレンダーを試みます。内部でresource.chartData.read()が呼び出されます。こちらのデータもまだ取得されていないので、このコンポーネントはSuspendします。Reactはこのコンポーネントも飛ばして、ツリーの他のコンポーネントのレンダーを試みます。</p>
<p>レンダーを試みる他のコンポーネントは残っていないので、ProfileDetails直上のSuspendのfallbackを表示します。</p>

```javascript
fallback={
  <Typography variant="p" component="h7">
    Loading chart...
  </Typography>
}
```
<p>このように、データが到着するごとに再レンダーを試み、そのたびに深いところまで表示できるようになります。Fetch-Then-Renderでも存在していたウォーターフォールの問題がありません。</p>
<p>Fetch-Then-Renderのようにプロフィールとグラフを同時に出現させたい場合は、ProfileChartをラップしているSuspenseを取り除けば可能です。</p>

```javascript
    <Suspense
      fallback={
        <Typography variant="p" component="h7">
          Loading profile...
        </Typography>
      }
    >
      <ProfileDetails />
       <ProfileChart />
    </Suspense>
```

<h3>4. Race Condition</h3>
![ezgif.com-gif-maker (3).gif](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/569054/a9a33bef-8e2b-0668-47a7-37941f6545ab.gif)
<p>Suspenseによるインターフェースプレビューの実装の前に、useEffectやcomponentDidMountでデータ取得を行った場合に引き起こされるRace condition(競合状態)についても検証しました。</p>
<p>ContentionalStateコンポーネントをつくり、ProfilePageと複数のプロフィールを切り替えるボタンを配置しました。</p>

```javascript
const getNextId = (id) => {
  return id === 3 ? 0 : id + 1;
};

export const ContentionState = () => {
  const [id, setId] = useState(0);
  return (
    <div>
      <Button
        variant="outlined"
        color="primary"
        onClick={() => setId(getNextId(id))}
      >
        次へ
      </Button>
      <ProfilePage id={id} />
    </div>
  );
};
```
<p>ProfilePageとProfileChartの両方にuseEffectがあり、idが変わるたびにそれぞれのデータを取得します。"次へ"ボタンを素早く押すと、プロフィールを別の ID に切り替えた後に以前のプロフィールのリクエストが返ってくることがあります。</p>
<p>React コンポーネントにはライフサイクルがありますが、非同期なリクエストにも同様に、発行したときに始まり、レスポンスを得た時に終わるというライフサイクルをもっています。このような複数のプロセスが互いに影響しあうことで、競合状態が起こります。</p>

<h6>ContentionalState.jsx</h6>
```javascript
const getNextId = (id) => {
  return id === 3 ? 0 : id + 1;
};

export const ContentionState = () => {
  const [id, setId] = useState(0);
  return (
    <div>
      <Button
        variant="outlined"
        color="primary"
        onClick={() => setId(getNextId(id))}
      >
        次へ
      </Button>
      <ProfilePage id={id} />
    </div>
  );
};

const ProfilePage = ({ id }) => {
  const [userData, setUserData] = useState(null);

  useEffect(() => {
    fetchUserData(id).then((u) => setUserData(u));
  }, [id]);

  if (userData === null) {
    return (
      <Typography variant="p" component="h7" style={{ marginLeft: 10 }}>
        Loading profile...
      </Typography>
    );
  }
  return (
    <div>
      <DetailsContent
        company={userData.data.company}
        name={userData.data.name}
        image={userData.data.image}
      />
      <ProfileChart id={id} />
    </div>
  );
};

const ProfileChart = ({ id }) => {
  const [chartData, setChartData] = useState(null);

  useEffect(() => {
    fetchChartData(id).then((p) => setChartData(p));
  }, [id]);

  if (chartData === null) {
    return (
      <Typography variant="p" component="h7">
        Loading chart...
      </Typography>
    );
  }

  return <ChartContent data={chartData} />;
};
```

<h3>5. Concurrent Mode</h3>
![ezgif.com-gif-maker (4).gif](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/569054/cd877f85-9925-9214-7c24-7dc0fa42ce3b.gif)
<p>ここからインターフェースプレビューを実装するのですが、まずはRace Conditionを解決する必要があります。</p>
<p>Render-as-You-Fetchの実装ではリソースをトップレベルの変数として定義していましたが、今回は複数リソースを扱うため、ConcurrentModeコンポーネント内で定義します。</p>

```javascript
const initialResource = fetchProfileData(0);

export const ConcurrentMode = () => {
  const [resource, setResource] = useState(initialResource);
```
<p>"次へ"ボタンのクリックハンドラで、プロフィールを切り替えるためのstateを設定し、さらにこのstateの更新をuseTransitionのstartTransitionでラップします。これにより、stateの更新で望ましくないローディング中の状態の表示が起きてしまった場合に、Reactがstate更新を遅延させることができます。</p>

```javascript
      <Button
        variant="outlined"
        color="primary"
        disabled={isPending}
        onClick={() => {
          startTransition(() => {
            const nextUserId = getNextId(resource.userId);
            setResource(fetchProfileData(nextUserId));
          });
        }}
      >
        次へ
      </Button>
```
<p>さらにuseTransitionのisPendingを使用することで、トランジションの完了を待機しているかどうかを確認することができ、これでようやく前の画面と"Loading..."を同時に表示するというインターフェースプレビュー の状態を実現することができました。</p>


```javascript
  const [startTransition, isPending] = useTransition({
    timeoutMs: 3000,
  });
```

<h6>ConcurrentMode.jsx</h6>

```javascript

const getNextId = (id) => {
  return id === 3 ? 0 : id + 1;
};

const initialResource = fetchProfileData(0);

export const ConcurrentMode = () => {
  const [resource, setResource] = useState(initialResource);
  const [startTransition, isPending] = useTransition({
    timeoutMs: 3000,
  });

  return (
    <div>
      <Button
        variant="outlined"
        color="primary"
        disabled={isPending}
        onClick={() => {
          startTransition(() => {
            const nextUserId = getNextId(resource.userId);
            setResource(fetchProfileData(nextUserId));
          });
        }}
      >
        次へ
      </Button>
      {isPending ? ' Loading...' : null}
      <ProfilePage resource={resource} />
    </div>
  );
};

const ProfilePage = ({ resource }) => {
  return (
    <Suspense
      fallback={
        <Typography variant="p" component="h7" style={{ marginLeft: 10 }}>
          Loading profile...
        </Typography>
      }
    >
      <ProfileDetails resource={resource} />
      <Suspense
        fallback={
          <Typography variant="p" component="h7">
            Loading chart...
          </Typography>
        }
      >
        <ProfileChart resource={resource} />
      </Suspense>
    </Suspense>
  );
};

const ProfileDetails = ({ resource }) => {
  const userData = resource.userData.read();
  return (
    <DetailsContent
      company={userData.data.company}
      name={userData.data.name}
      image={userData.data.image}
    />
  );
};

const ProfileChart = ({ resource }) => {
  const data = resource.chartData.read();
  return <ChartContent data={data} />;
};
```


<h2>おわりに</h2>
<p>公式Docsの説明が詳しかったこともあり、自分で実装しながらReactのレンダリングへの理解を深めることができました。Concurrent Modeは実験的機能であり、React Nativeにもまだ対応していません。アプリへの導入はまだ先になるかもしれませんが、正式リリースが今から楽しみです。</p>