9. 自動接続と接続状態

前回のデバイスに自動でつなぎ、状態をどの画面からでも読む

この章のゴール

1

デバイスを覚える

選んだ BLE のデバイスIDを shared_preferences に保存

2

自動でつなぐ

起動時に接続し、切れたらつなぎ直す

3

どの画面からでも

接続状態と電池残量を ref.watch で読む

全体の流れ

flowchart LR
  P[("shared_preferences<br/>bleDeviceId")] --> SEL["selectedBleDevice<br/>使うID"]
  SEL --> DEV["imuDevice<br/>Fake / BLE"]
  DEV --> CON["imuConnection<br/>接続状態・電池"]
  CON -- "ref.watch" --> H["ホーム"]
  CON -- "ref.watch" --> M["測定"]
  CON -- "ref.watch" --> D["デバイス"]

  • 保存した ID が 空なら偽物のセンサ(BLE の通信はしない)、あれば起動時にそのデバイスへ接続
  • 接続と電池の読み取りは imuConnection の中だけで行う。画面は読むだけ

パッケージを入れる

flutter pub add shared_preferences

SharedPreferencesAsync

読むたびに await する。たまにしか読まない値なら十分

SharedPreferencesWithCache

起動時に1回読み込み、以降は await なしで読める。この章ではこちら

古い SharedPreferences.getInstance()

以前からある API は、今後非推奨になる予定と案内されています。新しく書くなら Async / WithCache を使います。

電池残量の読み方(この講座の仮定)

項目 内容
サービス 標準の Battery Service 0x180F
キャラクタリスティック Battery Level 0x2A19(読み取り。0〜100 の 1byte)

ファームウェアに Battery Service がない場合

読み取りに失敗し、電池残量は表示されません(接続と測定には影響しません)。ファームウェアに Battery Service を追加すると表示されます。

保存する Repository

lib/repository/settings/device_settings_repository.dart
import 'package:shared_preferences/shared_preferences.dart';

// 端末に保存する設定(使うセンサのBLEデバイスID)
// DB に入れるほどではない小さな値は shared_preferences に保存する
class DeviceSettingsRepository {
  DeviceSettingsRepository(this._prefs);

  final SharedPreferencesWithCache _prefs;
  static const deviceIdKey = 'bleDeviceId';

  // 保存されていなければ null(= 偽物のセンサを使う)
  String? get deviceId => _prefs.getString(deviceIdKey);

  Future<void> saveDeviceId(String? deviceId) => deviceId == null
      ? _prefs.remove(deviceIdKey)
      : _prefs.setString(deviceIdKey, deviceId);
}
  • DB(drift)に入れるほどではない 小さな設定 は shared_preferences に保存する
  • 読み書きは Repository にまとめる(5章と同じ考え方)

起動前に読み込む(main)

lib/main.dart
import 'package:flutter/material.dart';
import 'package:hooks_riverpod/hooks_riverpod.dart';
import 'package:motion_app/app.dart';
import 'package:motion_app/provider/providers.dart';
import 'package:motion_app/repository/settings/device_settings_repository.dart';
import 'package:shared_preferences/shared_preferences.dart';

Future<void> main() async {
  WidgetsFlutterBinding.ensureInitialized(); // runApp の前に await するときに必要
  // 保存した設定を起動前に読み込んでおく → 以降は await なしで読める
  final prefs = await SharedPreferencesWithCache.create(
    cacheOptions: const SharedPreferencesWithCacheOptions(
      allowList: {DeviceSettingsRepository.deviceIdKey},
    ),
  );
  runApp(ProviderScope(
    overrides: [sharedPreferencesProvider.overrideWithValue(prefs)],
    child: const App(),
  ));
}
  • allowList に書いたキーだけ読み書きできる(キーの打ち間違いに気づける)
  • overrideWithValue で、読み込んだものを Provider に渡す

Provider に登録する

lib/provider/providers.dart
import 'package:riverpod_annotation/riverpod_annotation.dart';
import 'package:motion_app/domain/save_session_usecase.dart';
import 'package:motion_app/infrastructure/database/app_database.dart';
import 'package:motion_app/repository/session/session_repository.dart';
import 'package:motion_app/repository/settings/device_settings_repository.dart';
import 'package:motion_app/repository/user/user_repository.dart';
import 'package:motion_app/service/imu/ble_scanner.dart';
import 'package:motion_app/service/imu/dual_gy521_device.dart';
import 'package:motion_app/service/imu/fake_imu_device.dart';
import 'package:motion_app/service/imu/imu_device.dart';
import 'package:shared_preferences/shared_preferences.dart';

part 'providers.g.dart';

@Riverpod(keepAlive: true)
AppDatabase appDatabase(Ref ref) {
  final db = AppDatabase();
  ref.onDispose(db.close);
  return db;
}

@Riverpod(keepAlive: true)
UserRepository userRepository(Ref ref) =>
    UserRepository(ref.watch(appDatabaseProvider));

@Riverpod(keepAlive: true)
SessionRepository sessionRepository(Ref ref) =>
    SessionRepository(ref.watch(appDatabaseProvider));

// main で読み込んだものに差し替えて使う(差し替え忘れはすぐに気づけるようエラーにする)
@Riverpod(keepAlive: true)
SharedPreferencesWithCache sharedPreferences(Ref ref) =>
    throw UnimplementedError('main で overrideWithValue すること');

@Riverpod(keepAlive: true)
DeviceSettingsRepository deviceSettingsRepository(Ref ref) =>
    DeviceSettingsRepository(ref.watch(sharedPreferencesProvider));

// 使うセンサのBLEデバイスID。null なら偽物のセンサを使う
// 選んだIDは保存され、次に起動したときもそのデバイスにつなぐ
@Riverpod(keepAlive: true)
class SelectedBleDevice extends _$SelectedBleDevice {
  @override
  String? build() => ref.watch(deviceSettingsRepositoryProvider).deviceId;

  Future<void> select(String? deviceId) async {
    state = deviceId;
    await ref.read(deviceSettingsRepositoryProvider).saveDeviceId(deviceId);
  }
}

// 6軸センサ。デバイスが選ばれていればBLE、なければ偽物
@Riverpod(keepAlive: true)
ImuDevice imuDevice(Ref ref) {
  final deviceId = ref.watch(selectedBleDeviceProvider);
  final ImuDevice device =
      deviceId == null ? FakeImuDevice() : DualGy521Device(deviceId);
  ref.onDispose(device.dispose);
  return device;
}

@Riverpod(keepAlive: true)
BleScanner bleScanner(Ref ref) => BleScanner();

// センサのデータを Riverpod で購読できるようにする
@riverpod
Stream<ImuSample> imuSample(Ref ref) => ref.watch(imuDeviceProvider).samples;

@Riverpod(keepAlive: true)
SaveSessionUseCase saveSessionUseCase(Ref ref) => SaveSessionUseCase(
      sessionRepository: ref.watch(sessionRepositoryProvider),
    );
  • sharedPreferencesProvider は main で差し替える(忘れるとエラー)
  • 初期値が保存した ID → imuDevice も最初からそのデバイス

センサの窓口に接続を追加

lib/service/imu/imu_device.dart
import 'dart:math';

// 3軸の値(x, y, z)
class Vec3 {
  const Vec3(this.x, this.y, this.z);

  final double x;
  final double y;
  final double z;

  // ベクトルの大きさ(向きに関係なく、どれだけ強いか)
  double get magnitude => sqrt(x * x + y * y + z * z);
}

// 6軸センサ2個分の1回分のデータ(100Hz で届く)
// == はoverrideしない(同じ値が続いても Riverpod に間引かれないように)
class ImuSample {
  const ImuSample({
    required this.count,
    required this.acc1,
    required this.gyro1,
    required this.acc2,
    required this.gyro2,
  });

  final int count; // パケット番号
  final Vec3 acc1; // センサ1の加速度[g]
  final Vec3 gyro1; // センサ1の角速度[dps]
  final Vec3 acc2; // センサ2の加速度[g]
  final Vec3 gyro2; // センサ2の角速度[dps]
}

// 6軸センサの窓口。偽物(Fake)とBLEの本物を同じ形で扱えるようにする
abstract interface class ImuDevice {
  Stream<ImuSample> get samples; // 計測中に届くデータ
  Stream<bool> get connectionChanges; // 接続(true)・切断(false)の変化
  Future<void> connect();
  Future<void> disconnect();
  Future<int?> readBatteryLevel(); // 電池残量[%]。読めなければ null
  Future<void> start();
  Future<void> stop();
  Future<void> dispose();
}
  • これまでは start() の中で接続していた → 測定を始めるまで、つながるかわからない
  • 接続(connect)と測定(start)を分ける

偽物のセンサ

lib/service/imu/fake_imu_device.dart
import 'dart:async';
import 'dart:math';

import 'package:motion_app/service/imu/imu_device.dart';

// 実機がなくても動かせる偽物の6軸センサ
// start() すると 100Hz で、1.5秒ごとに「振る」動きをまねた値を流す
class FakeImuDevice implements ImuDevice {
  final _controller = StreamController<ImuSample>.broadcast();
  final _connection = StreamController<bool>.broadcast();
  final _random = Random();
  Timer? _timer;
  int _count = 0;
  int _battery = 100;

  @override
  Stream<ImuSample> get samples => _controller.stream;

  @override
  Stream<bool> get connectionChanges => _connection.stream;

  // 偽物なので、すぐにつながる
  @override
  Future<void> connect() async => _connection.add(true);

  @override
  Future<void> disconnect() async => _connection.add(false);

  // 読むたびに 1% ずつ減る電池
  @override
  Future<int?> readBatteryLevel() async => _battery = max(0, _battery - 1);

  @override
  Future<void> start() async {
    _timer?.cancel();
    _count = 0;
    _timer = Timer.periodic(const Duration(milliseconds: 10), (_) {
      final t = _count / 100; // 経過秒数
      // 1.5秒周期で 0 → 1 → 0 と鋭く変化する「振り」の強さ
      final swing = pow(sin(pi * (t % 1.5) / 1.5), 8).toDouble();
      double noise() => (_random.nextDouble() - 0.5) * 4;
      _controller.add(ImuSample(
        count: _count,
        acc1: Vec3(0, 0, 1 + 3 * swing), // 静止時は重力の 1g
        gyro1: Vec3(noise(), noise(), 800 * swing + noise()),
        acc2: Vec3(0, 0, 1 + 2 * swing),
        gyro2: Vec3(noise(), noise(), 500 * swing + noise()),
      ));
      _count++;
    });
  }

  @override
  Future<void> stop() async {
    _timer?.cancel();
    _timer = null;
  }

  @override
  Future<void> dispose() async {
    await stop();
    await _controller.close();
    await _connection.close();
  }
}
  • 実機がなくても、接続状態と電池残量の表示を確かめられる

実機のセンサ

lib/service/imu/dual_gy521_device.dart
import 'dart:async';
import 'dart:io';
import 'dart:typed_data';

import 'package:universal_ble/universal_ble.dart';
import 'package:motion_app/service/imu/imu_device.dart';
import 'package:motion_app/service/imu/imu_packet.dart';

// DualGY521_M5Stamp(6軸センサ×2、BLE)
// 1つのキャラクタリスティックで、コマンドの書き込みと測定データの通知を行う
class DualGy521Device implements ImuDevice {
  DualGy521Device(this.deviceId) {
    // 切断(電源オフ・電波が届かない など)を見逃さないよう、OS からの通知で状態を持つ
    _connectionSub =
        UniversalBle.connectionStream(deviceId).listen((connected) {
      if (!connected) _connected = false;
    });
  }

  final String deviceId;
  static final _service =
      BleUuidParser.string('4fafc201-1fb5-459e-8fcc-c5c9c331914b');
  static final _chara =
      BleUuidParser.string('beb5483e-36e1-4688-b7f5-ea07361b26a8');
  // 標準の Battery Service / Battery Level(0〜100 の 1byte)
  static final _batteryService = BleUuidParser.string('180f');
  static final _batteryLevel = BleUuidParser.string('2a19');
  static final _startCommand = Uint8List.fromList([0x01, 0x00]); // 連続測定開始
  static final _stopCommand = Uint8List.fromList([0x01, 0x01]); // 連続測定停止

  final _controller = StreamController<ImuSample>.broadcast();
  StreamSubscription<Uint8List>? _valueSub;
  late final StreamSubscription<bool> _connectionSub;
  bool _connected = false;

  @override
  Stream<ImuSample> get samples => _controller.stream;

  @override
  Stream<bool> get connectionChanges => UniversalBle.connectionStream(deviceId);

  @override
  Future<void> connect() async {
    if (_connected) return;
    // 見つからないときに長く待たないよう、10秒で諦める(既定は60秒)
    await UniversalBle.connect(deviceId, timeout: const Duration(seconds: 10));
    await UniversalBle.discoverServices(deviceId); // 通知の有効化の前に必要
    if (Platform.isAndroid) {
      // 52byte のデータが1回で届くよう、通信サイズ(MTU)を広げる(iOS/macOS は自動)
      await UniversalBle.requestMtu(deviceId, 128);
    }
    await _valueSub?.cancel();
    _valueSub = UniversalBle.characteristicValueStream(deviceId, _chara)
        .listen(_onValue);
    // 暗号化された通信のため、初回は OS のペアリング画面で PIN(123456)を入力する
    await UniversalBle.subscribeNotifications(deviceId, _service, _chara);
    _connected = true;
  }

  @override
  Future<void> disconnect() async {
    await _valueSub?.cancel();
    _valueSub = null;
    _connected = false;
    await UniversalBle.disconnect(deviceId);
  }

  @override
  Future<int?> readBatteryLevel() async {
    if (!_connected) return null;
    try {
      final value =
          await UniversalBle.read(deviceId, _batteryService, _batteryLevel);
      return value.isEmpty ? null : value[0];
    } catch (_) {
      return null; // Battery Service がない機器では読めない
    }
  }

  @override
  Future<void> start() async {
    await connect(); // つながっていなければ、ここでつなぐ
    await UniversalBle.write(deviceId, _service, _chara, _startCommand);
  }

  void _onValue(Uint8List value) {
    final sample = ImuPacket.tryParse(value);
    if (sample != null) _controller.add(sample);
  }

  @override
  Future<void> stop() async {
    if (!_connected) return;
    await UniversalBle.write(deviceId, _service, _chara, _stopCommand);
  }

  @override
  Future<void> dispose() async {
    await _connectionSub.cancel();
    await _valueSub?.cancel();
    if (_connected) await UniversalBle.disconnect(deviceId);
    await _controller.close();
  }
}

実機のセンサのポイント

  • connectionStream で、電源オフや電波切れによる 切断を受け取る
  • 接続のタイムアウトは 10 秒(既定の 60 秒だと、機器がないときに長く待たされる)
  • start() でも connect() を呼ぶ。自動接続が間に合っていなくても測定できる
  • 電池が読めなくても例外にせず null を返す(表示しないだけ)

保存した ID の注意点

Android

ID は機器の MAC アドレス。どの端末から見ても同じ

iOS / macOS

OS が割り当てた UUID。端末ごとに違う ので、別の端末には持っていけない。同じ端末なら、検索し直さずにそのままつながる

  • 起動直後に OS の Bluetooth の許可や PIN 入力の画面が出ることがある → 接続は裏で行い、画面の表示を止めない

接続状態をアプリ全体で1つ持つ

lib/provider/imu_connection.dart
import 'dart:async';

import 'package:freezed_annotation/freezed_annotation.dart';
import 'package:riverpod_annotation/riverpod_annotation.dart';
import 'package:motion_app/provider/providers.dart';

part 'imu_connection.g.dart';
part 'imu_connection.freezed.dart';

enum ImuConnectionStatus { disconnected, connecting, connected }

@freezed
abstract class ImuConnectionState with _$ImuConnectionState {
  const factory ImuConnectionState({
    @Default(ImuConnectionStatus.disconnected) ImuConnectionStatus status,
    int? batteryLevel, // 電池残量[%]。まだ読めていなければ null
    @Default(false) bool hasError, // 何度試してもつながらなかった
  }) = _ImuConnectionState;
}

// センサとの接続状態と電池残量。アプリ全体で1つ
// どの画面からでも ref.watch(imuConnectionProvider) で読める
@Riverpod(keepAlive: true)
class ImuConnection extends _$ImuConnection {
  static const _retryCount = 3;
  static const _retryDelay = Duration(seconds: 3);
  static const _batteryInterval = Duration(seconds: 30);
  Timer? _batteryTimer;

  @override
  ImuConnectionState build() {
    // 使うデバイスが変わると、ここからやり直される(古いデバイスは切断される)
    final device = ref.watch(imuDeviceProvider);
    final sub = device.connectionChanges.listen(_onConnectionChanged);
    ref.onDispose(() {
      sub.cancel();
      _batteryTimer?.cancel();
    });
    // build の中では state を変えられないので、build が終わってから自動で接続を始める
    Future.microtask(connect);
    return const ImuConnectionState();
  }

  Future<void> connect() async {
    if (!ref.mounted || state.status != ImuConnectionStatus.disconnected) return;
    final device = ref.read(imuDeviceProvider);
    state = const ImuConnectionState(status: ImuConnectionStatus.connecting);
    // 電源が入っていない・遠いなどでつながらないときは、少し待って数回だけ試す
    for (var i = 0; i < _retryCount; i++) {
      try {
        await device.connect();
        if (!ref.mounted) return;
        _onConnected();
        return;
      } catch (_) {
        await Future<void>.delayed(_retryDelay);
        if (!ref.mounted) return;
      }
    }
    state = const ImuConnectionState(hasError: true);
  }

  // 自分で切断する(自動でつなぎ直さない)
  Future<void> disconnect() async {
    final device = ref.read(imuDeviceProvider);
    _batteryTimer?.cancel();
    state = const ImuConnectionState(); // 先に切断済みにして、つなぎ直しを防ぐ
    await device.disconnect();
  }

  void _onConnected() {
    state = const ImuConnectionState(status: ImuConnectionStatus.connected);
    // 電池残量は画面ごとではなく、ここでまとめて定期的に読む
    _readBattery();
    _batteryTimer?.cancel();
    _batteryTimer = Timer.periodic(_batteryInterval, (_) => _readBattery());
  }

  Future<void> _readBattery() async {
    final level = await ref.read(imuDeviceProvider).readBatteryLevel();
    if (!ref.mounted || state.status != ImuConnectionStatus.connected) return;
    state = state.copyWith(batteryLevel: level);
  }

  void _onConnectionChanged(bool connected) {
    // つながっていたのに切れた(電源オフ・電波が届かない)ときだけ、つなぎ直す
    if (connected || state.status != ImuConnectionStatus.connected) return;
    _batteryTimer?.cancel();
    state = const ImuConnectionState();
    connect();
  }
}

ImuConnection のポイント

  • keepAlive: true → 画面を閉じても接続を保つ。アプリ全体で1つ
  • ref.watch(imuDeviceProvider) → デバイスを選び直すと build からやり直す(古いデバイスは切断される)
  • つながらないときは 3 秒おきに 3 回まで。無限に試さない(電池の消費・OS の制限)
  • 自分で切断したときは、つなぎ直さない(先に state を切断済みにする)
  • 電池残量は画面ごとではなく、ここで 30 秒ごとに読む → 画面をいくつ開いても通信は1回

起動時に接続を始める

lib/app.dart
import 'package:flutter/material.dart';
import 'package:hooks_riverpod/hooks_riverpod.dart';
import 'package:motion_app/provider/imu_connection.dart';
import 'package:motion_app/router/router.dart';

class App extends ConsumerWidget {
  const App({super.key});

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    // 起動したらすぐにセンサへの接続を始める(どの画面を開いていても接続を保つ)
    ref.listen(imuConnectionProvider, (_, _) {});
    return MaterialApp.router(
      title: 'Motion Note',
      theme: ThemeData(colorSchemeSeed: Colors.teal),
      routerConfig: ref.watch(routerProvider),
    );
  }
}
  • Provider は 誰かが使ったとき に作られる。App で listen して、起動直後に作らせる
  • listen なので、接続状態が変わっても App は描き直されない

どの画面からでも読む

lib/ui/common/connection_status_chip.dart
import 'package:flutter/material.dart';
import 'package:hooks_riverpod/hooks_riverpod.dart';
import 'package:motion_app/provider/imu_connection.dart';
import 'package:motion_app/provider/providers.dart';

// センサの接続状態と電池残量。どの画面の AppBar にも置ける
class ConnectionStatusChip extends ConsumerWidget {
  const ConnectionStatusChip({super.key});

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final connection = ref.watch(imuConnectionProvider);
    final isFake = ref.watch(selectedBleDeviceProvider) == null;
    final battery = connection.batteryLevel;

    final (icon, label) = switch (connection.status) {
      ImuConnectionStatus.connected => (
          Icons.bluetooth_connected,
          '${isFake ? '偽物' : '接続済み'}${battery == null ? '' : '  電池 $battery%'}',
        ),
      ImuConnectionStatus.connecting => (Icons.bluetooth_searching, '接続中...'),
      ImuConnectionStatus.disconnected => (
          Icons.bluetooth_disabled,
          connection.hasError ? '接続できません' : '未接続',
        ),
    };
    return Padding(
      padding: const EdgeInsets.symmetric(horizontal: 8),
      child: Chip(avatar: Icon(icon, size: 18), label: Text(label)),
    );
  }
}
  • ref.watch するだけ。接続や電池の読み取りは、この Widget では行わない

ホームに置く

lib/ui/home/view/home_page.dart
import 'package:flutter/material.dart';
import 'package:go_router/go_router.dart';
import 'package:motion_app/router/router.dart';
import 'package:motion_app/ui/common/connection_status_chip.dart';

class HomePage extends StatelessWidget {
  const HomePage({super.key});

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('Motion Note'),
        actions: const [ConnectionStatusChip()],
      ),
      body: ListView(
        padding: const EdgeInsets.all(16),
        children: [
          Card(
            child: ListTile(
              leading: const Icon(Icons.people),
              title: const Text('ユーザー'),
              trailing: const Icon(Icons.chevron_right),
              onTap: () => context.push(Routes.users),
            ),
          ),
          Card(
            child: ListTile(
              leading: const Icon(Icons.bluetooth),
              title: const Text('デバイス'),
              trailing: const Icon(Icons.chevron_right),
              onTap: () => context.push(Routes.device),
            ),
          ),
        ],
      ),
    );
  }
}

測定画面: select で必要な値だけ

lib/ui/measurement/view/measurement_page.dart
import 'package:flutter/material.dart';
import 'package:go_router/go_router.dart';
import 'package:hooks_riverpod/hooks_riverpod.dart';
import 'package:motion_app/provider/imu_connection.dart';
import 'package:motion_app/ui/common/connection_status_chip.dart';
import 'package:motion_app/ui/measurement/view_model/measurement_view_model.dart';

class MeasurementPage extends ConsumerWidget {
  const MeasurementPage({super.key, required this.userId});

  final String userId;

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final state = ref.watch(measurementViewModelProvider(userId));
    final notifier = ref.read(measurementViewModelProvider(userId).notifier);
    // 必要な値だけを select で取り出す → 電池残量が変わっても描き直されない
    final isConnected = ref.watch(imuConnectionProvider
        .select((s) => s.status == ImuConnectionStatus.connected));
    final big = Theme.of(context).textTheme.displaySmall;

    return Scaffold(
      appBar: AppBar(
        title: const Text('測定'),
        actions: const [ConnectionStatusChip()],
      ),
      body: Center(
        child: Column(
          mainAxisSize: MainAxisSize.min,
          children: [
            Text('センサ1  ${state.gyro1.toStringAsFixed(0)} dps', style: big),
            Text('センサ2  ${state.gyro2.toStringAsFixed(0)} dps', style: big),
            const SizedBox(height: 8),
            Text('${(state.sampleCount / 100).toStringAsFixed(1)} 秒'),
            const SizedBox(height: 32),
            state.isMeasuring
                ? FilledButton.icon(
                    icon: const Icon(Icons.stop),
                    label: const Text('停止して保存'),
                    onPressed: () async {
                      final result = await notifier.stopAndSave();
                      if (result == null || !context.mounted) return;
                      if (result.isPersonalBest) {
                        ScaffoldMessenger.of(context).showSnackBar(
                          const SnackBar(content: Text('自己ベスト更新!')),
                        );
                      }
                      context.pop(true);
                    },
                  )
                : FilledButton.icon(
                    icon: const Icon(Icons.play_arrow),
                    label: const Text('測定開始'),
                    onPressed: isConnected ? notifier.start : null, // つながるまで押せない
                  ),
          ],
        ),
      ),
    );
  }
}
  • select → 「つながっているか」が変わったときだけ描き直す(電池残量が変わっても描き直さない)

ref.watch してよいもの・避けるもの

ref.watch してよい

  • 接続状態・電池残量など、ときどき変わる値
  • 変わるのは数秒〜数十秒に1回

ref.watch を避ける

  • 100Hz で届く測定値
  • 見ている画面すべてが 1秒に100回 描き直される
  • 6章のように ref.listen で受け、間引いてから state にする

デバイス画面

lib/ui/device/view/device_page.dart
import 'package:flutter/material.dart';
import 'package:hooks_riverpod/hooks_riverpod.dart';
import 'package:motion_app/provider/imu_connection.dart';
import 'package:motion_app/provider/providers.dart';
import 'package:motion_app/ui/common/connection_status_chip.dart';
import 'package:motion_app/ui/device/view_model/device_view_model.dart';

class DevicePage extends ConsumerWidget {
  const DevicePage({super.key});

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final state = ref.watch(deviceViewModelProvider);
    final notifier = ref.read(deviceViewModelProvider.notifier);
    final selectedId = ref.watch(selectedBleDeviceProvider);
    final connection = ref.watch(imuConnectionProvider);
    // 保存されているが、今回の検索結果にないデバイス
    final isSavedOnly = selectedId != null &&
        state.devices.every((d) => d.deviceId != selectedId);

    return Scaffold(
      appBar: AppBar(
        title: const Text('デバイス'),
        actions: const [ConnectionStatusChip()],
      ),
      floatingActionButton: FloatingActionButton.extended(
        icon: const Icon(Icons.bluetooth_searching),
        label: Text(state.isScanning ? '検索中...' : '検索'),
        onPressed: state.isScanning ? null : notifier.scan,
      ),
      body: RadioGroup<String?>(
        groupValue: selectedId,
        onChanged: notifier.select,
        child: ListView(
          children: [
            const RadioListTile<String?>(
              value: null,
              title: Text('偽物のセンサ(実機なし)'),
            ),
            if (isSavedOnly)
              RadioListTile<String?>(
                value: selectedId,
                title: const Text('保存されているデバイス'),
                subtitle: Text(selectedId),
              ),
            if (connection.hasError)
              ListTile(
                leading: const Icon(Icons.error_outline),
                title: const Text('接続できませんでした'),
                trailing: TextButton(
                  onPressed: notifier.reconnect,
                  child: const Text('再接続'),
                ),
              ),
            if (state.errorMessage != null)
              ListTile(title: Text(state.errorMessage!)),
            for (final device in state.devices)
              RadioListTile<String?>(
                value: device.deviceId,
                title: Text(device.name ?? ''),
                subtitle: Text('${device.deviceId}  RSSI ${device.rssi ?? '-'}'),
              ),
          ],
        ),
      ),
    );
  }
}
  • 今回の検索で見つからなくても、保存したデバイスは一覧に出す(選択中であることがわかる)

デバイス画面の ViewModel

lib/ui/device/view_model/device_view_model.dart
import 'package:freezed_annotation/freezed_annotation.dart';
import 'package:riverpod_annotation/riverpod_annotation.dart';
import 'package:motion_app/provider/imu_connection.dart';
import 'package:motion_app/provider/providers.dart';
import 'package:universal_ble/universal_ble.dart';

part 'device_view_model.g.dart';
part 'device_view_model.freezed.dart';

@freezed
abstract class DeviceState with _$DeviceState {
  const factory DeviceState({
    @Default([]) List<BleDevice> devices,
    @Default(false) bool isScanning,
    String? errorMessage,
  }) = _DeviceState;
}

@riverpod
class DeviceViewModel extends _$DeviceViewModel {
  @override
  DeviceState build() => const DeviceState();

  Future<void> scan() async {
    state = state.copyWith(isScanning: true, errorMessage: null);
    try {
      final devices = await ref.read(bleScannerProvider).scan();
      state = state.copyWith(devices: devices, isScanning: false);
    } catch (e) {
      state = state.copyWith(isScanning: false, errorMessage: '$e');
    }
  }

  // 選んだデバイスは保存され、自動でつなぎに行く
  Future<void> select(String? deviceId) =>
      ref.read(selectedBleDeviceProvider.notifier).select(deviceId);

  // つながらなかったときに、もう一度試す
  Future<void> reconnect() => ref.read(imuConnectionProvider.notifier).connect();
}

チェックポイント

CHECK 0 / 5