# ExpoでLive Activityのタイマーを作る

By Tarik Pinarci (https://tarikpinarci.com). Published 2025-05-01. Canonical: https://tarikpinarci.com/ja/blog/expo-live-activity-timer

iOSのLive Activitiesはゲームチェンジャーです。アプリがロック画面やDynamic Islandにリアルタイムの更新をそのまま表示できます。当然、私はワークアウトのタイマーがそこで動いていたらどんなにかっこいいだろうと想像し始めました。スマートフォンのロックを解除しなくても、ユーザーのモチベーションを保てます。でも落とし穴がありました。Live ActivitiesはSwiftやActivityKitのようなAppleのネイティブツールで作られています。そんなときに見つけたのが[expo-apple-targets](https://github.com/EvanBacon/expo-apple-targets)というツールです。モジュールを丸ごと一から書かずに済み、思っていたよりずっと簡単に進められました。この記事では、iOS向けのタイマー型Live Activityをどう作ったのか、どんな手順を踏んだのか、そして途中で何を学んだのかを紹介します。

## Live Activitiesに夢中になった理由

Live Activitiesはただのかっこいい小技ではありません。ユーザーエンゲージメントのゲームチェンジャーです。Appleの[Human Interface Guidelines](https://developer.apple.com/design/human-interface-guidelines/live-activities)では、時間が重要なタスクについて「最新で、ひと目でわかる情報」を届ける方法として説明されています。ワークアウト中にプランクの時間を表示するフィットネスアプリ、ピザの配達状況を追跡するフードデリバリーアプリ、ドライバーの到着予定時刻を更新する配車アプリを想像してみてください。すべてロック画面に、そしてiPhone 14 Pro以降ならDynamic Islandに表示されます。ロックを解除しなくても、アプリの一番大事な更新を見られるVIPパスをユーザーに渡すようなものです。

私は、セット中にワークアウトのタイマーが進んでいくのをユーザーに見てもらい、アプリを開かせることなく集中を保ってほしいと思いました。アプリをプロっぽく感じさせるのはこういう仕上げであり、私は全力で取り組むことにしました。でも、ネイティブのレイヤーにまったく触れずにこれをすべて扱うことはできないので、Swiftに飛び込み、Xcodeと格闘することになるのはわかっていました。そこで見つけたのが[expo-apple-targets](https://github.com/EvanBacon/expo-apple-targets)です。ExpoのJavaScriptの世界とiOSのネイティブ機能の間の溝を埋めてくれるパッケージです。[Evan Bacon](https://x.com/Baconbrix)には大きな感謝を。このツールのおかげで、気が遠くなるような作業が、難しいけれど解けるパズルのように感じられました。

## 全体像: ExpoアプリでのLive Activities

Live ActivitiesはiOSだけのお楽しみです。Swiftベースのフレームワークで動くActivityKitによって実現されているので、好むと好まざるとにかかわらずネイティブのコードを書くことになります。Expoアプリにとって、これは魚に木登りをさせようとするようなものです。不可能ではありませんが、それなりの努力が必要です。そこでexpo-apple-targetsが、経験豊富なガイドのように登場します。ネイティブモジュールやウィジェット拡張を一から作らずに済むフレームワークを提供してくれるのです。これはExpoのモジュールシステム([Expo Modules API](https://docs.expo.dev/modules/module-api/))の上に作られていて、Swiftでネイティブコードを書いてJavaScriptに公開できるので、全体の作業が歯の根管治療ほど苦痛ではなくなります。

## プロジェクトのセットアップ

始めるのは決して楽ではありませんでしたが、expo-apple-targetsのおかげでなんとかなりました。私は次のように始めました。

- **expo-apple-targetsのインストール**: npm install expo-apple-targetsをさっと実行すれば準備完了です。パッケージのREADMEは宝の山で、Xcodeでウィジェット拡張を追加し、app.jsonにLive Activityのentitlement(com.apple.developer.activitykit)を追加する手順を案内してくれます。

- **ネイティブモジュールのセットアップ**: Expoのモジュールシステムを使って、ActivityKitとやり取りするSwiftモジュールを作りました。[Expo Modulesのドキュメント](https://docs.expo.dev/modules/module-api/)では、関数のシグネチャとイベントを明確に定義することが強調されていて、そのおかげでstartActivityのようなメソッドを苦労せずにJavaScriptに公開できました。

- **ウィジェット拡張**: ここでSwiftUIの出番です。ロック画面とDynamic Island向けにLive Activityの見た目をデザインできました。expo-apple-targetsはウィジェットのテンプレートを提供してくれますが、進んでいくタイマーとインタラクティブなボタンを表示するためにカスタマイズする必要がありました。

- **インテント**: これを使うと、ユーザーはウィジェット上のボタンをタップしてタイマーを一時停止したり再開したりできます。expo-apple-targetsはインテントのセットアップを簡単にしてくれますが、それでも通知が正しく流れるようにするまで、いくつかの誤動作をデバッグする必要がありました。

## 毎秒更新されるタイマー?

![開発者が意気揚々と1秒ごとのタイマー更新を実装し、タイマーが暴れてシステムが混乱した過負荷状態に陥る様子。([gpt-4oで生成](https://openai.com/index/hello-gpt-4o/))](https://cdn-images-1.medium.com/max/2048/1*Nq1a3rqsEIBCgTsAWdvgNQ.png)_開発者が意気揚々と1秒ごとのタイマー更新を実装し、タイマーが暴れてシステムが混乱した過負荷状態に陥る様子。([gpt-4oで生成](https://openai.com/index/hello-gpt-4o/))_

最初にタイマーに取り組んだとき、私の頭は「_現在時刻でLive Activityを毎秒更新すればいい_」と言いました。簡単そうですよね? 違いました。Live Activityのタイマーを更新できるかについて開発者たちが議論している[Redditのスレッド](https://www.reddit.com/r/iOSProgramming/comments/18n12wh/how_does_this_app_achieve_to_update_its_live/?rdt=52173)にたまたま行き当たりました。結論は満場一致で、毎秒更新するのは大惨事だというものでした。ハムスターの回し車で宇宙船を動かそうとするようなものです。動きはしますが、すぐに燃え尽きます。絶え間ない更新はCPUを酷使し、バッテリーを消耗させ、アプリを重くします。

そのRedditのスレッドで目が覚めました。Appleの[SwiftUIのドキュメント](<https://developer.apple.com/documentation/swiftui/text/init(timerinterval:pausetime:countsdown:showshours:)>)でSwiftUIのText(timerInterval:)を見つけたとき、まさに目から鱗でした。このビューはタイマーの更新をネイティブに処理してくれるので、Live Activity全体を再描画しなくても時間が進んでいきます。退屈な部分をiOSに任せて、自分は楽しい部分に集中できるようなものです。

そこで私は毎秒更新する計画を捨て、startedAt/pausedAtのアプローチを採用しました。これが優れている理由は次のとおりです。

- **パフォーマンス**: 毎秒更新を送る代わりに、タイマーの開始時刻(startedAt)と一時停止した時刻(一時停止中ならpausedAt)を保存します。ウィジェットはText(timerInterval:)を使ってstartedAtに基づいたライブのタイマーを表示し、一時停止中はpausedAtを使って静的な時間を表示します。これでAPI呼び出しをほぼゼロにまで減らせます。

- **バッテリー効率**: 頻繁な更新はバッテリーを吸い取る吸血鬼です。時間を進める処理をSwiftUIに任せることで、アプリは身軽なままで、ユーザーのスマートフォンも快適です。

- **APIの規約への準拠**: AppleのLive Activity APIは、リアルタイムに大量の更新を送り続けるためには作られていません。startedAt/pausedAtの構成はiOSの想定にうまく沿っていて、レート制限を受ける可能性を減らします。

- **コードのシンプルさ**: 2つのタイムスタンプを管理するほうが、更新の流れをさばくよりずっと簡単です。コードはきれいなままで、私のストレスも抑えられます。

このアプローチは、ゲームで秘密の近道を見つけたような感覚でした。タイマーはなめらかに動き、見た目も良く、リソースを占有しません。正しい方向を示してくれたRedditのスレッド([もう一度リンクを貼っておきます](https://www.reddit.com/r/iOSProgramming/comments/18n12wh/how_does_this_app_achieve_to_update_its_live/?rdt=52173))には勲章をあげたいくらいです。

## Live Activityの心臓部

コードを1行ずつ説明して退屈させるつもりはありません。このタイマーを動かしている重要なスニペットに絞りましょう。完全なソースコードは記事の最後にGitHubで共有します。

### LiveActivityAttributes構造体

この構造体はLive Activityの骨格であり、そのデータと、データがどう変化していくかを定義します。

```swift
    struct LiveActivityAttributes: ActivityAttributes {
      public struct ContentState: Codable, Hashable {
        var startedAt: Date
        var pausedAt: Date?

        func getElapsedTimeInSeconds() -> TimeInterval {
          if let pausedAt = pausedAt {
            return pausedAt.timeIntervalSince(startedAt)
          } else {
            return Date().timeIntervalSince(startedAt)
          }
        }
        func isRunning() -> Bool {
          return pausedAt == nil
        }
        func getFormattedElapsedTime() -> String {
          let elapsed = getElapsedTimeInSeconds()
          let totalSeconds = Int(elapsed)
          let hours = totalSeconds / 3600
          let minutes = (totalSeconds % 3600) / 60
          let seconds = totalSeconds % 60
          if hours > 0 {
            return String(format: "%d:%02d:%02d", hours, minutes, seconds)
          } else {
            return String(format: "%d:%02d", minutes, seconds)
          }
        }
        func getFutureDate() -> Date {
          return Date().addingTimeInterval(365 * 24 * 60 * 60)
        }
      }
      var activityName: String
      var activityIcon: String
    }
```

これはLive ActivityのDNAのようなものです。外側のLiveActivityAttributesは静的なもの、つまりアクティビティの開始時に設定されるactivityName(例: 「Workout」)とactivityIcon(例: 「RUNNING」)を保持します。内側のContentStateで実際の動きが起こり、startedAt(タイマーが始まった時刻)とpausedAt(一時停止した時刻、一時停止していれば)を追跡します。本当の主役はヘルパーメソッドです。

- getElapsedTimeInSeconds()は、タイマーがどれくらい動いていたかを計算します。一時停止中ならpausedAtで止め、動いているなら現在時刻を使います。これでロジックが引き締まり、再利用しやすくなります。

- isRunning()はシンプルなチェックです。pausedAtがnullなら、タイマーは動いています。ほかの場所で面倒なstateのチェックをしなくて済む、すっきりした方法です。

- getFormattedElapsedTime()は、秒数をウィジェット用のきれいな「MM:SS」または「HH:MM:SS」の文字列に変換します。マラソンのような超長時間のワークアウトをするユーザーもいるかもしれないと気づいて、時間の表示に対応しました。

- getFutureDate()は1年後の日付を設定します。これをText(timerInterval:)に渡すことで、終了日を気にせずにタイマーを無期限に動かせます。

この構造体が物事を整理してくれるところが気に入っています。上手に詰めたバックパックのように、必要なものはすべてあり、不要なものは何もありません。CodableとHashableに準拠しているので、更新のためのシリアライズやSwiftUIでの利用が簡単で、モジュールとウィジェットの間でstateを同期するときに本当に助かりました。

### Live Activityを開始する

startActivity関数は魔法が始まる場所で、新しいLive Activityを立ち上げます。

```swift
    AsyncFunction("startActivity") { (activityName: String, activityIcon: String) -> String in
        if #available(iOS 16.2, *) {
            await self.endAllActivities()
            self.startedAt = Date()
            self.pausedAt = nil
            if !ActivityAuthorizationInfo().areActivitiesEnabled {
                return ""
            }
            let attributes = LiveActivityAttributes(activityName: activityName, activityIcon: activityIcon)
            let contentState = LiveActivityAttributes.ContentState(startedAt: self.startedAt!, pausedAt: nil)
            do {
                let activity = try Activity.request(attributes: attributes, content: .init(state: contentState, staleDate: nil), pushType: nil)
                self.currentActivityId = activity.id
                self.sendTimerUpdateEvent()
                return activity.id
            } catch {
                throw error
            }
        }
        return ""
    }
```

この関数は火をつける火花です。Expoのモジュールシステムを通してJavaScriptに公開されていて、React Nativeアプリから名前とアイコンを渡して呼び出せます。やっていることは次のとおりです。

- iOS 16.2以降かどうかを確認します。それより前のバージョンにはLive Activitiesが存在しません。

- endAllActivities()を呼んで、既存のアクティビティをすべて片付けます。iOSでは複数のLive Activitiesを同時に持てますが、混乱を避けるためにひとつずつにしたかったのです。

- startedAtを現在時刻に設定し、pausedAtをクリアして、タイマーを動かす準備をします。

- Live Activitiesが有効になっているかを確認します(ユーザーは設定で無効にできるのですが、最初はこれにかなり戸惑いました)。

- 渡された名前とアイコンでLiveActivityAttributesを、開始時刻でContentStateを作ります。

- Activity.requestで新しいアクティビティをリクエストし、一意のIDを持つActivityオブジェクトを受け取ります。

- IDを保存し、JavaScriptに更新イベントを送り、アプリが追跡できるようにIDを返します。

### タイマーを一時停止する

タイマーの一時停止はperformPauseが担当し、Live Activityのstateを更新します。

```swift
    private func performPause(activityId: String?) async -> Bool {
        guard #available(iOS 16.2, *), self.pausedAt == nil else {
            return false
        }
        let targetId = activityId ?? self.currentActivityId
        guard let targetId = targetId else {
            return false
        }
        guard let activity = await self.findActivityById(targetId) else {
            return false
        }
        guard let currentStartedAt = self.startedAt else {
            return false
        }
        let now = Date()
        self.pausedAt = now
        let contentState = LiveActivityAttributes.ContentState(startedAt: currentStartedAt, pausedAt: self.pausedAt)
        await activity.update(using: contentState)
        self.sendTimerUpdateEvent()
        return true
    }
```

ここでstartedAt/pausedAtのアプローチが真価を発揮します。ユーザーが(アプリまたはウィジェットから)タイマーを一時停止すると、この関数は次のことを行います。

- iOS 16.2以降であること、タイマーがまだ一時停止されていないことを確認します(二重の一時停止は許しません)。

- アクティビティのIDを取得し、渡されていなければcurrentActivityIdにフォールバックします。

- 動いているアクティビティを検索するfindActivityByIdを使って、アクティビティを見つけます。

- pausedAtを現在時刻に設定し、タイマーを止めます。

- 元のstartedAtと新しいpausedAtで、新しいContentStateを作ります。

- activity.updateでアクティビティを更新し、ウィジェットに一時停止した時間を表示させます。

- アプリのUIを同期させるため、JavaScriptにイベントを送ります。

ここでのロジックは精度がすべてです。(pausedAt == nilのような)ひとつひとつのチェックは、存在しないアクティビティを一時停止するといった奇妙なエッジケースを防ぐためにあります。イベント処理については[Expo Modulesのドキュメント](https://docs.expo.dev/modules/overview/)を頼りにし、sendEventを使ってJavaScriptに更新を送りました。この関数の初期のバージョンではstartedAtを検証していなかったため、タイマーの表示がおかしくなることがありました。教訓: stateは必ずガードすること。

## ロック画面のビュー

LockScreenLiveActivityViewは、スマートフォンがロックされているときにユーザーが目にするものなので、見た目がしっかりしていなければなりません。

![ロック画面のLive Activity](https://cdn-images-1.medium.com/max/2000/1*IZ1ZSG7_99jfTMBJosePGQ.png)_ロック画面のLive Activity_

```swift
    struct LockScreenLiveActivityView: View {
        let context: ActivityViewContext<LiveActivityAttributes>
        var body: some View {
            ZStack {
                Color.black.opacity(0.8)
                    .clipShape(RoundedRectangle(cornerRadius: 16))
                HStack(spacing: 16) {
                    VStack(alignment: .leading, spacing: 12) {
                        HStack(spacing: 8) {
                            ActivityIcon(activityIcon: mapJSIconToSFSymbol(context.attributes.activityIcon),
                                        themeColor: .white,
                                        size: 18)
                            Text(context.attributes.activityName)
                                .font(.headline)
                                .foregroundColor(.white)
                        }
                        VStack(alignment: .leading, spacing: 4) {
                            if !context.state.isRunning() {
                                Text(context.state.getFormattedElapsedTime())
                                    .font(.system(size: 34, weight: .semibold, design: .rounded))
                                    .foregroundColor(.white)
                                    .fontWeight(.medium)
                                    .monospacedDigit()
                            } else {
                                Text(timerInterval: context.state.startedAt...context.state.getFutureDate(),
                                     pauseTime: nil,
                                     countsDown: false,
                                     showsHours: false)
                                    .font(.system(size: 34, weight: .semibold, design: .rounded))
                                    .foregroundColor(.white)
                                    .fontWeight(.medium)
                                    .monospacedDigit()
                            }
                        }
                    }
                    .frame(maxHeight: .infinity, alignment: .center)
                    Spacer()
                    VStack {
                        Spacer()
                        if context.state.isRunning() {
                            Button(intent: PauseIntent()) {
                                ZStack {
                                    Circle()
                                        .fill(Color(hex: "#007bff"))
                                        .frame(width: 44, height: 44)
                                    Image(systemName: "pause.fill")
                                        .font(.system(size: 18, weight: .bold))
                                        .foregroundColor(.white)
                                }
                            }
                            .buttonStyle(PlainButtonStyle())
                        } else {
                            HStack(spacing: 8) {
                                Button(intent: CompleteIntent()) {
                                    ZStack {
                                        Circle()
                                            .fill(Color(hex: "#28a745"))
                                            .frame(width: 44, height: 44)
                                        Image(systemName: "checkmark")
                                            .font(.system(size: 16, weight: .bold))
                                            .foregroundColor(.white)
                                    }
                                }
                                .buttonStyle(PlainButtonStyle())
                                Button(intent: ResumeIntent()) {
                                    ZStack {
                                        Circle()
                                            .fill(Color(hex: "#007bff"))
                                            .frame(width: 44, height: 44)
                                        Image(systemName: "play.fill")
                                            .font(.system(size: 18, weight: .bold))
                                            .foregroundColor(.white)
                                    }
                                }
                                .buttonStyle(PlainButtonStyle())
                            }
                        }
                        Spacer()
                    }
                }
                .padding(16)
            }
        }
    }
```

これはLive Activityの見た目の心臓部であり、SwiftUIが本領を発揮する場所です。ビューは左右の2つに分かれています。

- **左側**: アクティビティの名前、アイコン、タイマーを表示します。タイマーが動いている場合は、Text(timerInterval:)が重い仕事を引き受け、startedAtから1年後まで(getFutureDateのおかげで)カウントアップします。一時停止中は、getFormattedElapsedTimeによる静的な時間を表示します。.monospacedDigit()モディファイアで数字がくっきり見え、フォントも太字で読みやすくなるよう調整しました。

- **右側**: ボタンを扱います。動いているときは青い一時停止ボタンがあります。一時停止中は、アプリを開く緑のチェックマークと、再開する青い再生ボタンが表示されます。各ボタンはインテントを発火し、それをネイティブモジュールが受け取って処理します。

## [Dynamic Island](https://developer.apple.com/design/human-interface-guidelines/live-activities#The-Dynamic-Island)に飛び込む

![Dynamic Islandのビュー](https://cdn-images-1.medium.com/max/2000/1*iqy0d6FZe9UU0Tce7qCDug.png)_Dynamic Islandのビュー_

このスニペットは、Dynamic Islandの3つのモード、つまり展開(フル表示)、コンパクト(縮小)、最小(必要最低限)で、Live Activityがどう表示されるかを定義します。

```swift
    dynamicIsland: { context in
      DynamicIsland {
        DynamicIslandExpandedRegion(.leading) {
          VStack(alignment: .leading, spacing: 8) {
            HStack(spacing: 8) {
              ActivityIcon(activityIcon: mapJSIconToSFSymbol(context.attributes.activityIcon),
                          themeColor: .white,
                          size: 18)

              Text(context.attributes.activityName)
                .foregroundColor(.white)
                .font(.system(size: 16, weight: .semibold))
            }

            if !context.state.isRunning() {
              Text(context.state.getFormattedElapsedTime())
                .font(.system(size: 32, weight: .bold, design: .rounded))
                .foregroundColor(.white)
                .fontWeight(.medium)
                .monospacedDigit()
            } else {
              Text(timerInterval: context.state.startedAt...context.state.getFutureDate(),
                   pauseTime: nil,
                   countsDown: false,
                   showsHours: false)
                .font(.system(size: 32, weight: .bold, design: .rounded))
                .foregroundColor(.white)
                .fontWeight(.medium)
                .monospacedDigit()
            }
          }
          .padding(.leading, 8)
        }

        DynamicIslandExpandedRegion(.trailing) {
          VStack {
            Spacer()

            if context.state.isRunning() {
              Button(intent: PauseIntent()) {
                ZStack {
                  Circle()
                    .fill(Color(hex: "#007bff"))
                    .frame(width: 44, height: 44)
                  Image(systemName: "pause.fill")
                    .font(.system(size: 18, weight: .bold))
                    .foregroundColor(.white)
                }
              }
              .buttonStyle(PlainButtonStyle())
              .padding(.horizontal, 8)
            } else {
              HStack(spacing: 8) {
                Button(intent: CompleteIntent()) {
                  ZStack {
                    Circle()
                      .fill(Color(hex: "#28a745"))
                      .frame(width: 44, height: 44)
                    Image(systemName: "checkmark")
                      .font(.system(size: 16, weight: .bold))
                      .foregroundColor(.white)
                  }
                }
                .buttonStyle(PlainButtonStyle())

                Button(intent: ResumeIntent()) {
                  ZStack {
                    Circle()
                      .fill(Color(hex: "#007bff"))
                      .frame(width: 44, height: 44)
                    Image(systemName: "play.fill")
                      .font(.system(size: 18, weight: .bold))
                      .foregroundColor(.white)
                  }
                }
                .buttonStyle(PlainButtonStyle())
              }
            }
          }
          .frame(maxHeight: .infinity)
        }
      } compactLeading: {
        HStack(spacing: 4) {
          ActivityIcon(activityIcon: mapJSIconToSFSymbol(context.attributes.activityIcon),
                      themeColor: .white,
                      size: 16)

          Text(context.attributes.activityName)
            .foregroundColor(.white)
            .font(.system(size: 12))
            .lineLimit(1)
            .truncationMode(.tail)
        }
      } compactTrailing: {
        if !context.state.isRunning() {
          Text(context.state.getFormattedElapsedTime())
            .foregroundColor(.white)
            .monospacedDigit()
            .font(.system(size: 12, weight: .medium))
        } else {
          Text(timerInterval: context.state.startedAt...context.state.getFutureDate(),
               pauseTime: nil,
               countsDown: false,
               showsHours: false)
            .foregroundColor(.white)
            .monospacedDigit()
            .font(.system(size: 12, weight: .medium))
        }
      } minimal: {
        ActivityIcon(activityIcon: mapJSIconToSFSymbol(context.attributes.activityIcon),
                    themeColor: .white,
                    size: 12)
      }
    }
```

- [\*\*展開モード](https://developer.apple.com/design/human-interface-guidelines/live-activities#Expanded-presentation)\*\*: 長押しで表示され、.leadingと.trailingに分かれています。leading側にはアイコン(例: 走っている人)と名前(「Workout」)を縦に並べ、大きなタイマーを表示します。一時停止中は静的(getFormattedElapsedTime)、動作中は時間が進みます(Text(timerInterval:))。trailing側にはボタンがあります。動作中は青い一時停止ボタン、一時停止中は緑のチェックマーク(アプリを開く)と青い再生ボタン(再開)です。Islandの曲線に収まるよう、フォントと余白を調整しました。

- [\*\*コンパクトモード](https://developer.apple.com/design/human-interface-guidelines/live-activities#Compact-presentation)\*\*: スペースが狭くなると、compactLeadingは小さなアイコンと省略された名前を表示し、compactTrailingはタイマー(静的または進行中)を表示します。.lineLimit(1)で名前がすっきり収まり、12ポイントのフォントで読みやすさを確保しています。

- [\*\*最小モード](https://developer.apple.com/design/human-interface-guidelines/live-activities#Minimal-presentation)\*\*: 極端に狭いので、ダンベルのような12ポイントのアイコンだけで「タイマーはまだ動いているよ」と伝えます。シンプルですが効果的です。

## \_sharedフォルダ: なぜ重要なのか

![_sharedフォルダの概要](https://cdn-images-1.medium.com/max/2000/1*OdZlqw2AXJeTakpTlghLDQ.png)_\_sharedフォルダの概要_

[expo-apple-targets](https://github.com/EvanBacon/expo-apple-targets?tab=readme-ov-file#_shared)の\_sharedフォルダはトップレベルのディレクトリで、必要なコードをメインのアプリのターゲットと、Live Activityのウィジェットのようなサブターゲットの両方にリンクするためのものです。

ウィジェットのような拡張は別のプロセスで動くため、特定のファイルをメインアプリのターゲットだけでなく、拡張のターゲットにもリンクする必要があります。\_sharedフォルダを使うと、これらのファイルが自動的に両方にリンクされるので、手動の設定が不要になります。私のタイマーでは、LiveActivityAttributes構造体をここに置きました。これでアプリとウィジェットが同じタイマーのstate(startedAt、pausedAt)を同期の問題なく共有できるようになりました。

## Live Activityのウィジェットからアプリを起動する

CompleteIntentを使うと、ユーザーはLive Activityのウィジェット上のチェックマークボタンをタップしてアプリを開き、タイマーを終えたことを伝えられます。ワークアウトを締めくくるための、シンプルですが欠かせない操作です。

```swift
    import AppIntents
    import WidgetKit

    @available(iOS 16.2, *)
    struct CompleteIntent: AppIntent, LiveActivityIntent {
        static var title: LocalizedStringResource = "Complete Exercise"
        static var description: IntentDescription = "Opens the app to complete the exercise"
        static var openAppWhenRun: Bool = true

        init() {}
        func perform() async throws -> some IntentResult {
            NotificationCenter.default.post(name: Notification.Name("completeActivityFromWidget"), object: nil)

            return .result()
        }
    }
```

ユーザーが緑のチェックマークをタップすると、このインテントが発火し、completeActivityFromWidget通知を投げます。ネイティブモジュールがそれを受け取り、JavaScriptにonWidgetCompleteActivityイベントを送ります。そして[openAppWhenRun](https://developer.apple.com/documentation/appintents/openurlintent/openappwhenrun): trueのおかげで、iOSがアプリを開きます。

## インテントでユーザーのタップを処理する

PauseIntentは、ウィジェットをインタラクティブにしているインテントのひとつです。

![ロック画面のLive Activityのインテント](https://cdn-images-1.medium.com/max/2000/1*k2nzvHgwgqj6tFESIFcmbw.png)_ロック画面のLive Activityのインテント_

```swift
    import AppIntents
    import WidgetKit

    @available(iOS 16.2, *)
    struct PauseIntent: AppIntent, LiveActivityIntent {
      static var title: LocalizedStringResource = "Pause Timer"
      static var description: IntentDescription = "Pauses the current timer."

      init() {}

      func perform() async throws -> some IntentResult {
        NotificationCenter.default.post(name: Notification.Name("pauseTimerFromWidget"), object: nil)
        return .result()
      }
    }
```

このインテントは、ユーザーがウィジェットの一時停止ボタンをタップしたときに発火します。とてもシンプルですが強力です。

- ネイティブモジュールがsetupNotificationObserversで受け取る通知(pauseTimerFromWidget)を投げます。

- するとモジュールがperformPauseを実行し、Live Activityのstateを更新してJavaScriptに通知します。

ここで素晴らしいのは、インテントがシームレスなループを作ることです。ユーザーがタップし、インテントが発火し、モジュールが更新し、アプリが同期されたままになります。expo-apple-targetsはテンプレートを提供してくれるので、インテントのセットアップはとても簡単でしたが、それでもタップが反応しないケースをデバッグする必要がありました。原因は、通知名のスペルミスでした。よくある話です。[Expo Modulesのドキュメント](https://docs.expo.dev/modules/overview/)のおかげで、ネイティブの操作から発生するイベントの扱い方を理解でき、それがこの仕組みを動かす鍵になりました。

## JavaScriptと通信するイベント

![](https://cdn-images-1.medium.com/max/2000/1*F5GUBNYqWxbZbLU8-LZ0Ug.png)

次のセクションのイベントは、Expoのイベントシステムを使って、ネイティブモジュールがReact NativeアプリをLive Activityのstateと同期させる仕組みです。

### onWidgetCompleteActivity

このイベントは、ユーザーがチェックマークをタップしてアクティビティを完了したときに、CompleteIntentによって発火します。

```swift
    @objc func completeIntentHandler(_ notification: Notification) {
        guard let currentId = self.currentActivityId, self.startedAt != nil else {
            return
        }

        let elapsed = self.calculateElapsedTime()

        sendEvent("onWidgetCompleteActivity", [
            "activityId": currentId,
            "elapsedTime": Int(elapsed)
        ])
    }
```

completeIntentHandlerはcompleteActivityFromWidget通知を受け取り、経過時間を計算して、アクティビティのIDと経過秒数を付けてonWidgetCompleteActivityイベントをJavaScriptに送ります。JavaScript側では、アプリのUIを更新したり、ワークアウトの完了を記録したりできます。

### onLiveActivityUpdate

このイベントは、タイマーのstateが変わるたびに(例: 一時停止、再開)発火します。

```swift
    private func sendTimerUpdateEvent() {
        guard let currentId = self.currentActivityId else { return }
        guard self.startedAt != nil else { return }

        let state = self.pausedAt == nil ? "active" : "paused"
        let elapsed = self.calculateElapsedTime()

        sendEvent("onLiveActivityUpdate", [
            "state": state,
            "elapsedTime": Int(elapsed),
            "activityId": currentId
        ])
    }
```

stateの変更後に(performPauseやperformResumeの中などで)呼ばれ、現在のstate(「active」または「paused」)、経過時間、アクティビティのIDを付けてonLiveActivityUpdateイベントを送ります。JavaScriptはこれをリッスンして、アプリのタイマーのUIをウィジェットと同期させます。

どちらのイベントも、ネイティブモジュールとJavaScriptの間に緊密なフィードバックループを作ります。

## なぜこれが重要なのか

このLive Activityは単なるタイマーではありません。アプリをiOSのネイティブな一員のように感じさせる機能です。重要な理由は次のとおりです。

- **ユーザーエンゲージメント**: ロック画面やDynamic Islandにタイマーを表示することで、ユーザーは流れを中断せずにアプリとつながっていられます。一秒一秒が大事なワークアウトにぴったりです。

- **ネイティブらしい仕上がり**: ウィジェットのすっきりしたデザインとインタラクティブなボタンによって、アプリはクロスプラットフォームのおまけではなく、iOSにふさわしいものに感じられます。

- **パフォーマンス**: Text(timerInterval:)を活用したstartedAt/pausedAtのアプローチにより、バッテリーを消耗させたりAPIの制限に引っかかったりせずに、タイマーがなめらかに動きます。

ここでの縁の下の力持ちは、expo-apple-targetsと[Expo Modules API](https://docs.expo.dev/modules/module-api/)でした。JavaScriptとSwiftをつなぐための堅牢なフレームワークを提供してくれました。ドキュメントがすっきりした関数定義とイベント処理を重視していたおかげで、私のコードは整理され、保守しやすいものになりました。

## おわりに

このLive Activityは、ロック画面とDynamic Islandにリアルタイムの更新をそのまま表示し、アプリになめらかでネイティブな感触を加えてくれます。expo-apple-targets、Expo Modules API、そしてコミュニティからの知見(もちろんRedditのスレッドも含めて)のおかげで、実現するのはかなり簡単でした。Live Activitiesは、アプリをよりつながりのある、ダイナミックなものに感じさせる強力な方法です。

完全なソースコードのGitHubリポジトリはこちらです 👉🏻 [https://github.com/tarikfp/expo-live-activity-timer](https://github.com/tarikfp/expo-live-activity-timer)

