iPhone・Android・PC 間でデータを共有するなら、Google Keep が便利

 

🧑🏻‍💻 iPhone・Android・PC でデータを送りたい

スマートフォンとPCの間で、ちょっとしたデータを送りたいことがあります。

例えば、


iPhone → Android
Android → iPhone
iPhone → Windows PC
Android → Mac
PC → iPhone
PC → Android

といったケースです。

同じOSなら、AirDropやQuick Share など便利な方法があります。

しかし、iPhone・Android・Windows・Mac が混在すると、少し面倒です。

そこで便利なのが、Google Keep です。

 

🧑🏻‍💻 Google KeepならOSを気にしなくていい

Google Keep は、Android だけのアプリではありません。

スマートフォンだけでなく、PCのブラウザからも利用できます。


          Google Keep
               │
   ┌───────────┼───────────┐
   │           │           │
Android      iPhone      PC / Mac
   │           │           │
   └───────────┼───────────┘
               │
         Google Account

つまり、Google Keepを共有場所にすることで、OSの違いをあまり意識せずに済みます。

 

🧑🏻‍💻 Googleアカウントがあればいい

Google Keep の大きなメリットは、Google アカウントを使えることです。

例えば PC で調べた URL をスマートフォンに送りたいとします。


PC
 │
 │ URLをKeepに保存
 ▼
Google Keep
 │
 │ 同期
 ▼
iPhone / Android

スマートフォン側でGoogle Keepを開けば、そのURLを確認できます。

逆に、


iPhone
   │
   │ テキストを保存
   ▼
Google Keep
   │
   │ 同期
   ▼
Windows PC

のように、スマートフォンからPCへ送ることもできます。

 

🧑🏻‍💻 「自分の端末間」で使うのが簡単

実は、Google Keep の便利さは自分の複数端末をつなぐ用途で特に分かりやすいです。

例えば、


       ┌──── iPhone
       │
       ├──── Android
Google ┤
Keep   ├──── Mac
       │
       └──── Windows PC

すべて同じ Google アカウントでログインしておけば、Keep のメモを各端末から確認できます。

「自分の iPhone から自分の Mac へ URL を送りたい」といった用途なら、かなり手軽です。

 

🧑🏻‍💻 他の人とも共有できる

Google Keep は、自分の端末間だけでなく他の人との共有にも使えます。

共有相手の Google アカウントを指定すれば、同じメモを共同編集できます。


      Google Keep
      /         \
     /           \
自分の Google    相手の Google
  Account         Account
     │               │
  Android          iPhone
     │               │
    PC              PC

そのため、

・ 自分の Android → 家族の iPhone
・ 自分の Mac → 同僚の Windows
・ 自分の iPhone → 自分の PC

のような使い方もできます。

 

🧑🏻‍💻 「Google アカウントは今どき持っている」がポイント

iPhone ユーザーでも Google アカウントを持っている人は珍しくありません。

Android ユーザーなら、Google アカウントを利用しているケースはさらに多いでしょう。

PC でもブラウザから Google Keep を利用できます。

そのため、特別なアプリや専用の転送ケーブルを用意しなくても、OSの違いを超えて情報を共有できます。

 

🧑🏻‍💻 まとめ

iPhone・Android・Windows・Mac が混在する環境では、データ共有の方法に悩みがちです。

Google Keepなら、

・ Android
・ iPhone / iPad
・ Windows
・ Mac
・ Chromebook

などから同じデータにアクセスできます。

特に、

・ URL
・ テキスト
・ メモ
・ チェックリスト
・ 小さな画像

のようなちょっとしたデータを別の端末へ渡す用途に向いています。

「iPhone か Android か」ではなく、「Google Keep を共有場所にする」と考えると、端末間のデータ共有がかなりシンプルになります。


Jetpack Compose で巨大化した UiState をどう整理するか

見通しが悪くなった UiState を、責務ごとに整理する7つの方法

 

🧑🏻‍💻 1. Loading / Error / Success が混ざっているなら sealed interface にする

まず、ありがちなパターンです。

変更前:


data class UiState(
    val isLoading: Boolean,
    val error: String?,
    val items: List<Item>
)

- isLoading、error、items の組み合わせで画面の状態を表しています。
- しかし、これでは「Loading なのに items が入っている」「Error なのに isLoading が true」といった、あり得ない状態も作れてしまいます。

変更後:


sealed interface UiState {
    data object Loading : UiState
    data class Error(val message: String) : UiState
    data class Success(val items: List<Item>) : UiState
}

- Loading、Error、Success を、そのまま画面の状態として表現します。
- 状態を Boolean や nullable なプロパティの組み合わせで表現する必要がなくなります。

 

🧑🏻‍💻 2. フィールドが増えすぎたら、Sub-Stateにまとめる

UiState にプロパティを追加していった結果、何がどこに関係しているのか分からなくなることがあります。

変更前:


data class UiState(
    val title: String,
    val query: String,
    val items: List<Item>,
    val selectedCategory: Category?
)

変更後:


data class UiState(
    val header: HeaderState,
    val filter: FilterState,
    val list: ListState
)

data class HeaderState(
    val title: String
)

data class FilterState(
    val query: String,
    val category: Category?
)

data class ListState(
    val items: List<Item>
)


-「ヘッダー」「検索・フィルター」「リスト」という画面上のまとまりで整理します。
- UiState の中身を見ただけで、どの状態がどの役割なのか分かるようになります。

 

🧑🏻‍💻 3. UIだけで使う状態はComposableに閉じ込める

すべての状態をViewModelの UiState に入れる必要はありません。

変更前:


data class UiState(
    val items: List<Item>,
    val isExpanded: Boolean
)

変更後:


data class UiState(
    val items: List<Item>
)

@Composable
fun Screen(state: UiState) {
    var isExpanded by rememberSaveable {
        mutableStateOf(false)
    }
}

- isExpanded が画面の一時的な表示状態にすぎないなら、ViewModelに持たせる必要はありません。
- remember / rememberSaveable に移すことで、UiState をシンプルにできます。

例えば次のようなものです。

・一時的な展開状態
・アニメーションの状態
・Tooltipの表示状態
・フォーカス状態
・スクロール位置

ただし、スクロール位置などを画面復元やビジネスロジック上の理由で ViewModel 側に保持する必要がある場合は例外です。

 

🧑🏻‍💻 4. 計算できる値はStateとして持たない

「元のStateから計算できる値」まで UiState に入れてしまうと、Stateがどんどん増えていきます。

変更前:


data class UiState(
    val items: List<Item>,
    val filteredItems: List<Item>,
    val isEmpty: Boolean
)

変更後:


data class UiState(
    val items: List<Item>,
    val query: String
)

val filteredItems =
    state.items.filter { it.name.contains(state.query) }

val isEmpty = filteredItems.isEmpty()

- filteredItems は items と query から計算できます。
- isEmpty も filteredItems から計算できます。
- つまり、わざわざStateとして保存する必要がありません。
- ViewModelで StateFlow を組み合わせるなら combine や map、Compose 内で Compose State から値を導出するなら derivedStateOf などを使います。

 

🧑🏻‍💻 5. ViewModelまで巨大になったら、ViewModelを分ける

UiState が巨大になった原因が、そもそもViewModelがいろいろな責務を持ちすぎているケースもあります。

変更前:


class MainViewModel : ViewModel() {
    val headerState = ...
    val searchState = ...
    val contentState = ...
}

Stateを分けていても、ViewModel自体がすべてを管理しています。

変更後:


class HeaderViewModel : ViewModel() {
    val state = ...
}

class ContentViewModel : ViewModel() {
    val state = ...
}

@Composable
fun MainScreen(
    header: HeaderViewModel,
    content: ContentViewModel
) {
    HeaderSection(header.state)
    ContentSection(content.state)
}

- 「State を分割する」だけではなく、責務そのものを分けるという考え方です。
- ただし、Composable ごとに ViewModel を作る、という意味ではありません。
- 独立した責務やライフサイクルがある場合に検討します。

 

🧑🏻‍💻 6. 大量のデータを UiState に詰め込まない

数千件、数万件のデータをそのまま UiState に持たせるケースでは、そもそもStateの持ち方を見直します。

変更前:


data class UiState(
    val items: List<Item>
)

val uiState = repository.loadAllItems()

変更後:


data class UiState(
    val query: String
)
val items =
    repository.items()
        .cachedIn(viewModelScope)

- 検索条件などの画面状態と、大量のデータを分離します。
- Paging が適しているケースでは、Paging を利用して必要なデータを段階的に扱います。

 

🧑🏻‍💻 7. 1つの巨大な StateFlow に全部詰め込まない

すべての状態を1つの UiState にまとめることが、かえって分かりにくくなるケースもあります。

変更前:


data class UiState(
    val header: HeaderState,
    val search: SearchState,
    val content: ContentState
)

val uiState: StateFlow<UiState> = ...

変更後:


val headerState: StateFlow<HeaderState> = ...
val searchState: StateFlow<SearchState> = ...
val contentState: StateFlow<ContentState> = ...

@Composable
fun Screen(viewModel: MainViewModel) {
    Header(viewModel.headerState)
    Search(viewModel.searchState)
    Content(viewModel.contentState)
}

- 各 State が本当に独立しているなら、無理に1つへまとめる必要はありません。
- それぞれの UI が必要な State だけを受け取る形にできます。
- ただし、何でも StateFlow に分ければいいわけではありません。

 

🧑🏻‍💻 まとめ - どう整理するか


巨大な UiState
      │
      ├─ Loading / Error / Success が混在
      │       → sealed interface
      │
      ├─ フィールドが増えすぎた
      │       → Sub-State
      │
      ├─ UIだけで使う状態
      │       → remember / rememberSaveable
      │
      ├─ 計算すれば求められる値
      │       → Derived State
      │
      ├─ ViewModelの責務が多すぎる
      │       → ViewModelを分割
      │
      ├─ 大量のデータを保持している
      │       → Pagingなどを検討
      │
      └─ 独立した状態が混在している
              → StateFlowを分割

重要なのは、「UiStateの行数を減らす」ことではありません。

まず、今 UiState に入っているものを見て、


これは本当にStateなのか?
        ↓
UIだけのStateでは?
        ↓
計算できる値では?
        ↓
別の責務では?
        ↓
大量データでは?

と整理していくことです。

つまり、巨大な UiState は、Stateの責務を見直すきっかけと考えると分かりやすいです。

注意点:

- UiState が大きいこと自体が悪いわけではありません。
- StateFlow を細かく分けすぎると、今度は State 同士の関係が分かりにくくなります。
- sealed interface は、Loading / Error / Successのように本当に相互排他的な状態に使います。
- rememberSaveable に移すか ViewModel に残すかは、画面再生成やプロセス終了後にも復元する必要があるかも判断材料になります。
- Pagingも「List が大きいから必ず使う」というものではありません。

 

🤔 参考


ComposableView の闇

Jetpack Compose を導入したからといって、アプリが「Compose アプリ」になったわけではありません。

多くのプロジェクトでは、XML を ComposeView に置き換えただけで移行を終えています。

しかし、その状態は Compose の世界と View の世界の両方を同時に抱える アーキテクチャです。

一見すると移行できたように見えますが、実際には複雑さが増えていることも少なくありません。

 

🧑🏻‍💻 Compose に見えて、実は View

ComposeView は名前の通り View です。


Activity
└── Fragment
    └── ComposeView
        └── Composition

つまり、Compose を書いていても、

- Activity のライフサイクル
- Fragment のライフサイクル
- View のライフサイクル
- Composition のライフサイクル

という複数のライフサイクルの上で動いています。

Compose 本来のシンプルさは、この時点ではまだ得られていません。

 

🧑🏻‍💻 View のルールから逃げられない

Compose だけなら意識しなくて済むことも、ComposeView では必要になります。

例えば Composition の破棄タイミング。


composeView.setViewCompositionStrategy(
    ViewCompositionStrategy.DisposeOnViewTreeLifecycleDestroyed
)

これを適切に設定しなければ、Composition が期待どおり破棄されないケースがあります。

Compose アプリでは考えなくてよいことを、ComposeView では考える必要があります。

 

🧑🏻‍💻 Fragment は消えていない

ComposeView を使う構成は、多くの場合こうなります。


Fragment
    ↓
ComposeView
    ↓
Composable

これは

Fragment を Compose に置き換えた

のではありません。

実際には

Fragment の中へ Compose を埋め込んだ

だけです。

Fragment の責務もライフサイクルも Navigation も、そのまま残っています。

 

🧑🏻‍💻 「View を Compose に置き換える」は移行の半分

Compose 化というと、多くの人は View を Composable に書き換えることを思い浮かべます。

しかし、本当に変わるのは UI だけではありません。

Compose First の設計では、

- Fragment が不要になる
- XML が不要になる
- ViewBinding が不要になる
- FragmentManager への依存が減る
- Navigation の考え方が変わる
- State の持ち方も変わる

つまり、アーキテクチャ全体が変わります。

 

🧑🏻‍💻 Navigation 3 が示している未来

Navigation 3 のサンプルを見ると、Fragment は登場しません。


Activity
    ↓
NavDisplay
        ↓
Composable Screen

画面そのものが Composable になり、状態は Compose の仕組みを中心に管理されます。

ここでは ComposeView は必要ありません。

Compose がアプリの土台になっています。

 

🧑🏻‍💻 ComposeView は悪者ではない

もちろん ComposeView が悪いわけではありません。

既存アプリを段階的に Compose へ移行するには、とても重要な仕組みです。

大規模アプリでは、一気に Compose へ移行できるケースはほとんどありません。

だから ComposeView は今でも価値があります。

問題なのは、

ComposeView を使っている状態を「Compose 化が完了した状態」と思ってしまうことです。

 

🧑🏻‍💻 本当の Compose 化とは

本当の Compose 化は、単に XML を消すことではありません。


XML
    ↓
ComposeView
    ↓
Fragment を減らす
    ↓
Navigation を Compose 中心へ
    ↓
State 管理を Compose に合わせる
    ↓
Single Activity

この変化によって初めて、

Compose のシンプルな設計思想をそのまま活かせるようになります。

 

🧑🏻‍💻 おわりに

「ComposeView を使っています。」

この一文だけでは、そのアプリが Compose アプリなのか、View アプリなのかは分かりません。

もし ComposeView が Fragment の中にあり、Fragment Navigation の上で動いているなら、それはまだ View ベースのアプリに Compose を埋め込んでいる状態です。

Compose の本当の価値は、UI を書き換えることではありません。

アーキテクチャそのものをシンプルにできること。

そこまで進んだとき、ようやく「Compose 化した」と言えるのではないでしょうか。


【Kotlin】コピペで使える「null」を消すテクニック頻出順40

 

🧑🏻‍💻 1. Non-null を基本にする


// 悪い
val name: String?

// 良い
val name: String

Nullable を作らないことが最も重要。

 

🧑🏻‍💻 2. DTOだけ Nullable


data class UserResponse(
    val name: String?
)

外部データだけ Nullable にする。

 

🧑🏻‍💻 3. Domain は Non-null


data class User(
    val name: String
)

アプリ内部では Non-null を維持する。

 

🧑🏻‍💻 4. Repositoryで吸収する


fun load(): User =
    api.load()?.toUser() ?: User.EMPTY

Repository より先へ Nullable を持ち込まない。

 

🧑🏻‍💻 5. デフォルト値を使う


data class User(
    val name: String = ""
)

初期値で null を不要にする。

 

🧑🏻‍💻 6. orEmpty()


val name = user.name.orEmpty()

null を空文字へ変換する。

 

🧑🏻‍💻 7. emptyList()


fun users(): List<User> = emptyList()

List? を返さない。

 

🧑🏻‍💻 8. emptyMap()


fun settings(): Map<String, String> = emptyMap()

Map? を返さない。

 

🧑🏻‍💻 9. emptySet()


fun tags(): Set<String> = emptySet()

Set? を返さない。

 

🧑🏻‍💻 10. ?: return


val user = repository.find(id) ?: return

null を早期に除去する。

 

🧑🏻‍💻 11. ?: continue


val name = user.name ?: continue

ループ中の null をスキップする。

 

🧑🏻‍💻 12. ?: break


val item = iterator.nextOrNull() ?: break

null を終了条件として扱う。

 

🧑🏻‍💻 13. ?: error()


val token = token ?: error("Token required")

あり得ない null は即座に失敗させる。

 

🧑🏻‍💻 14. mapNotNull()


val names = users.mapNotNull { it.name }

変換と null 除去を同時に行う。

 

🧑🏻‍💻 15. filterNotNull()


val names = names.filterNotNull()

Collection の null を取り除く。

 

🧑🏻‍💻 16. Flow filterNotNull()


val users: Flow<User> =
    repository.userFlow.filterNotNull()

Flow の null を流さない。

 

🧑🏻‍💻 17. firstOrNull() ?: return


val user = users.firstOrNull() ?: return

最初の要素が無ければ早期終了する。

 

🧑🏻‍💻 18. by lazy


private val repository by lazy {
    UserRepository()
}

遅延初期化で Nullable を不要にする。

 

🧑🏻‍💻 19. Smart Cast(ローカル変数へ退避)


val user = currentUser ?: return

println(user.name)

Smart Cast を有効にして !! を避ける。

 

🧑🏻‍💻 20. StateFlow を Nullable にしない


private val uiState =
    MutableStateFlow(UserUiState())

StateFlow より状態オブジェクトを持つ。

 

🧑🏻‍💻 21. Compose State を Nullable にしない


var uiState by mutableStateOf(UserUiState())

mutableStateOf より状態オブジェクトを持つ。

 

🧑🏻‍💻 22. Java境界で Non-null 化する


val title: String =
    javaApi.title.orEmpty()

Platform Type (String!) を入口で閉じ込める。

 

🧑🏻‍💻 23. requireNotNull()


val user = requireNotNull(user)

引数や入力値の null を早期に拒否する。

 

🧑🏻‍💻 24. checkNotNull()


val database = checkNotNull(database)

オブジェクトの状態が不正なら失敗させる。

 

🧑🏻‍💻 25. Null Object Pattern


interface Logger

object EmptyLogger : Logger

Logger? の代わりに空実装を使う。

 

🧑🏻‍💻 26. sealed class / interface


sealed interface UiState {
    data object Loading : UiState
    data class Success(val users: List<User>) : UiState
    data class Error(val message: String) : UiState
}

null の代わりに状態を型で表現する。

 

🧑🏻‍💻 27. Result


fun load(): Result<User>

失敗を null ではなく Result で表現する。

 

🧑🏻‍💻 28. value class


@JvmInline
value class UserId(val value: Long)

IDなどを専用型にして null を減らす。

 

🧑🏻‍💻 29. takeIf()


val adult = user.takeIf { it.age >= 18 } ?: return

条件を満たさなければ早期終了する。

 

🧑🏻‍💻 30. firstNotNullOf()


val token = providers.firstNotNullOf {
    it.token
}

最初に見つかった Non-null 値を取得する。

 

🧑🏻‍💻 31. SharedFlow を使う


private val events = MutableSharedFlow<Event>(
    replay = 1
)

イベントでは StateFlow より SharedFlow が適している場合がある。

 

🧑🏻‍💻 32. Nothing を使う


fun fail(message: String): Nothing =
    throw IllegalStateException(message)

val token = token ?: fail("Token required")

Nothing を使うと独自のガード関数を作れる。

 

🧑🏻‍💻 33. !! を使わない


// 悪い
val user = user!!

// 良い
val user = requireNotNull(user)

!! より意図が明確な API を使う。

 

🧑🏻‍💻 34. let を減らす


// 悪い
user?.let {
    println(it.name)
}

// 良い
val user = user ?: return
println(user.name)

ネストを減らして読みやすくする。

 

🧑🏻‍💻 35. lateinit


private lateinit var repository: UserRepository

後から初期化する参照型では Nullable を避けられる。

 

🧑🏻‍💻 36. Delegates.notNull()


var count: Int by Delegates.notNull()

Int や Boolean など lateinit が使えない型向け。

 

🧑🏻‍💻 37. takeUnless()


val user = user.takeUnless { it.deleted } ?: return

条件を満たしたら除外したい場合に使う。

 

🧑🏻‍💻 38. firstNotNullOfOrNull()


val token = providers.firstNotNullOfOrNull {
    it.token
}

最初の Non-null を取得し、無ければ null を返す。

 

🧑🏻‍💻 39. Kotlin Contracts


@OptIn(ExperimentalContracts::class)
fun requireUser(user: User?) {
    contract {
        returns() implies (user != null)
    }
    requireNotNull(user)
}

独自関数でも Smart Cast を効かせられる。

 

🧑🏻‍💻 40. associateNotNull() パターン


val map = users
    .mapNotNull {
        it.id?.let { id -> id to it }
    }
    .toMap()

Map を作る途中で null を除外する。

 

🧑🏻‍💻 まとめ

「null」を未だに使ってるプロジェクト、実際現場では多いですよね。

「NullPointerExeption(ヌルポ)」の対応による開発時間の損失は、IT業界全体で年間数十兆円、個々の開発プロジェクトでも全体の数割の時間を奪うレベルの巨大なインパクトを持っています。


Navigation 3 時代でも ViewModel は State Holder であるべきか?

Compose と Navigation 3 が変えた ViewModel の役割

長年、Android 開発では一つの考え方が当たり前とされてきました。

画面の状態(State)は ViewModel に持たせる。

これは単なるベストプラクティスではなく、Android アーキテクチャの基本原則の一つでした。

ViewModel は Configuration Changes(画面回転など)でも破棄されず、さらに SavedStateHandle を使えば Process Death 後の状態復元もできます。

そのおかげで Activity や Fragment は UI を表示することに専念でき、画面の状態はすべて ViewModel が管理する、という設計が一般的になりました。

しかしここ数年で、この考え方は少しずつ変わり始めています。

Compose も Navigation 3 も ViewModel を不要にしたわけではありません。

代わりに、それぞれが 「本来その State を持つべき場所」 を用意するようになりました。

そこで、こんな疑問が生まれます。

Navigation 3 の時代でも、ViewModel は State Holder であるべきなのでしょうか?

 

🤔 以前の ViewModel は画面の State をすべて抱えていた

Compose が登場する以前は、多くの ViewModel が画面に関するほぼすべての状態を保持していました。


ViewModel
├── UI State
│   ├── text
│   ├── scrollPosition
│   ├── selectedTab
│   └── dialogState
│
├── Navigation State
│   └── screen arguments
│
└── Presentation Logic

この構成には多くのメリットがありました。

- Configuration Changes に強い
- Process Death 後も状態を復元できる
- Activity / Fragment をシンプルに保てる
- UI とビジネスロジックを分離できる

そのため、新しい State が増えたら、

とりあえず ViewModel に置く

という設計が自然になっていました。

 

🤔 Compose は UI State を UI に戻した

Jetpack Compose は、この考え方を少し変えました。

すべての UI State を ViewModel に持たせる必要はなく、Composable 自身が State を持てるようになったのです。

例えば検索文字列なら、


var query by remember {
    mutableStateOf("")
}

だけで十分です。

さらに Configuration Changes や Process Death を越えて保持したいなら、


var query by rememberSaveable {
    mutableStateOf("")
}

を使えます。

例えば次のような State は、

- TextField の入力内容
- 選択中のタブ
- 展開状態
- ダイアログの表示状態
- スクロール位置

どれも 純粋な UI State です。

ビジネスロジックではありません。

そのため、実際に使っている Composable の中に置く方が責務も分かりやすくなります。

Compose はまず、

「UI State は UI が持つ」

という考え方を広めました。

 

🤔 Navigation 3 はさらに一歩進めた

Navigation 3 は、この流れをさらに推し進めています。

まず、画面引数を SavedStateHandle 経由で受け渡す必要がなくなりました。

各画面は自分専用の NavKey を持ちます。


data class UserDetail(
    val userId: Long
) : NavKey

さらに Navigation 3 では rememberSerializable が追加されました。

rememberSaveable が Android の保存・復元機構を利用するのに対し、

rememberSerializableNavEntry 単位 で UI State を保持します。

つまり、UI State は Navigation の Back Stack と一緒に移動するようになります。

画面ごとの State を ViewModel に保存する必要はなく、

各画面自身が UI State を持つ

という構造になります。

役割を整理すると次のようになります。


UI State
    │
rememberSerializable
    │
Composable


Navigation State
    │
NavKey


Presentation Logic
    │
ViewModel

UI State は UI のもの。

Navigation State は Navigation のもの。

どちらも、もう ViewModel が管理すべき State ではありません。

 

🤔 では ViewModel には何が残るのか?

UI State も Navigation State も ViewModel の役割ではなくなったとしたら、

ViewModel は何を担当するのでしょうか?

実は、やることはまだたくさんあります。


ViewModel
├── Repository の調整
├── ビジネスロジック
├── Flow の変換
├── Paging
├── Retry
└── viewModelScope

ここで面白いことがあります。

この中には、

State そのものはほとんどありません。

あるのは責務です。

ViewModel は

- Repository からデータを取得し
- ユーザー操作に応答し
- ビジネスロジックを実行し
- UI が描画しやすい形へ加工する

という役割を担います。

 

🤔 ViewModel は「State Holder」ではなく「State Producer」へ

例えば次のような ViewModel を考えてみます。


val uiState = combine(
    userRepository.users,
    settingsRepository.settings
) { users, settings ->
    HomeUiState(
        users = users,
        darkMode = settings.darkMode
    )
}.stateIn(...)

ここで実際の State はどこにあるでしょうか。

ViewModel ではありません。

データの正しい管理場所(Single Source of Truth)は Repository にあります。

ViewModel は、それらを UI 用に変換しているだけです。

つまり ViewModel は

State を保持する存在ではなく、State を生成する存在

になりつつあります。

一見小さな違いに思えますが、

Presentation Layer の考え方を大きく変える変化です。

 

🤔 State を持つ責任は、それぞれのレイヤーへ

Compose より前は、


ViewModel
├── UI State
├── Navigation State
└── Presentation Logic

という構成が一般的でした。

Navigation 3 では、


rememberSerializable
└── UI State

NavKey
└── Navigation State

ViewModel
└── Presentation Logic

へと役割が整理されます。

Compose は UI State を UI に戻しました。

Navigation 3 は Navigation State を NavKey に任せ、

UI State を NavEntry ごとに保持できるようにしました。

ViewModel が不要になったわけではありません。

責務がより明確になった のです。

 

🤔 よりシンプルなアーキテクチャ

その結果、アーキテクチャは次のように整理できます。


+----------------------+
|      Composable      |
|----------------------|
| UI State             |
| rememberSerializable |
+----------+-----------+
           |
           v
+----------------------+
|      ViewModel       |
|----------------------|
| Presentation Logic   |
| Flow Transformation  |
| Repository Calls     |
+----------+-----------+
           |
           v
+----------------------+
|      Repository      |
|----------------------|
| Persistent Data      |
| DataStore / Database |
+----------------------+

各レイヤーが、それぞれ最も適した責務を持ちます。

- Composable は UI State
- NavKey は Navigation State
- Repository は永続データ
- ViewModel は Presentation Logic

責務が自然に分離された構造です。

 

🧑🏻‍💻 まとめ

Navigation 3 が登場しても、ViewModel が不要になるわけではありません。

ViewModel はこれまでどおり、

- ビジネスロジック
- Repository の調整
- Flow の変換
- Paging
- 長時間動作する Coroutine

などを担当する最適な場所です。

一方で、Compose は rememberSaveable を導入し、UI State を UI に持たせやすくしました。

さらに Navigation 3 は rememberSerializable を追加し、UI State を NavEntry ごとに保持できるようにしました。また、Navigation State は NavKey が担当します。

その結果、「とりあえず ViewModel に State を置く」という設計は、必ずしも最適ではなくなりました。

これからは、

この State を ViewModel に保存するにはどうすればいいか?

ではなく、

そもそも、この State は ViewModel が持つべきものなのか?

と考える方が自然でしょう。

ViewModel は今でも欠かせない存在です。

しかし Navigation 3 の時代における主な役割は、State Holder ではなく Presentation Logic を担うことへと変化しつつあります。

なお、UI State を ViewModel の外へ移したからといって、Configuration Changes や Process Death に弱くなるわけではありません。

- UI State は rememberSaveablerememberSerializable
- Navigation State は NavKey
- 永続データは Repository

というように、それぞれのレイヤーが適切な仕組みを使えば、Configuration Changes と Process Death の両方に対応した堅牢なアプリケーションを構築できます。

重要なのは State を保存することではなく、

「その State を最も自然に所有すべきレイヤーが管理すること」なのです。

 

🧑🏻‍💻 参考