【Flutter × Go × gRPC】OTAアップデート：Firmware更新をgRPCでアプリ通知

$ cd scripts/migrations
$ migrate create -ext sql -format 2006010215 add_firmware_version_to_users

// 2024040407_add_firmware_version_to_users.up.sql
ALTER TABLE users 
  ADD COLUMN firmware_version VARCHAR(20) DEFAULT '1.0.0';

// 2024040407_add_firmware_version_to_users.down.sql
ALTER TABLE users
  DROP COLUMN firmware_version;

// user_db.go
type User struct {
	ID                         int                  `db:"id" json:"id"`
	UID                        string               `db:"uid" json:"uid"`
	DeviceID                   types.NullString     `db:"device_id" json:"device_id"`
	// ... その他のフィールド ...
	SleepTransitionTime        types.NullInt64      `db:"sleep_transition_time" json:"sleep_transition_time"`
	HealthDataIntegrationStatus bool                `db:"healthdata_integration_status" json:"healthdata_integration_status"`
	FirmwareVersion            string      　　　　　 `db:"firmware_version" json:"firmware_version"` // ファームウェアバージョン
}

// notification.proto

syntax = "proto3";

package protos;
option go_package = "github.com/EarEEG-dev/clocky_be/pb";

import "shadow.proto";

// 既存の定義...
message StreamRequest {
  int32 userId = 1; // user id
}

message FirmwareUpdateAvailableResponse {
  int32 userId = 1;
  string message = 2;
  string new_firmware_version = 3;　　// 利用可能な新しいファームウェアのバージョン
}

service NotificationService {
  rpc Listen(StreamRequest) returns (stream StreamResponse);
  // ファームウェア更新通知用の新しいメソッド
  rpc ListenFirmwareUpdates(StreamRequest) returns (stream FirmwareUpdateAvailableResponse);
}

// grpc_server.go

type server struct {
	pb.UnimplementedHelloServiceServer
	pb.UnimplementedNotificationServiceServer
	grpcServer *GRPCServer
}

func (s *server) ListenFirmwareUpdates(req *pb.StreamRequest, stream pb.NotificationService_ListenFirmwareUpdatesServer) error {
	uid = req.UserId

	log.Printf("received listen firmware update request from user: %s", uid)

	// ファームウェアバージョンを取得するためにDBからユーザー情報を取得する
	user, err := GetUser(s.grpcServer.db, uid)
	if err != nil {
		return err
	}
	currentVersion := user.FirmwareVersion 
	
	// TODO：直書きしているがDBから読み込めるようにする
    const newFirmwareVersion = "1.0.1"
    
    response := &pb.FirmwareUpdateAvailableResponse{
        UserId:  req.UserId,
        Message: "Your firmware is up to date.",
        NewFirmwareVersion: currentVersion,
    }

    if newFirmwareVersion != currentVersion {
        response.Message = "NEW_FIRMWARE_AVAILABLE"
        response.NewFirmwareVersion = newFirmwareVersion
    }

    if err := stream.Send(response); err != nil {
		return status.Errorf(codes.Internal, "failed to send firmware update response: %v", err)
	}	

    <-stream.Context().Done()
    return stream.Context().Err()
}

// proto/notification.proto
syntax = "proto3";

package protos;
option go_package = "github.com/EarEEG-dev/clocky_be/pb";

message StreamRequest {
  int32 userId = 1; // user id
}

message FirmwareUpdateAvailableResponse {
  int32 userId = 1;
  string message = 2;
  string new_firmware_version = 3;
}

service NotificationService {
  rpc ListenFirmwareUpdates(StreamRequest) returns (stream FirmwareUpdateAvailableResponse);
}

protoc --dart_out=grpc:lib/grpc -Iprotos protos/notification.proto

// lib/grpc/notification.pbgrpc.dart
$grpc.ResponseStream<$0.FirmwareUpdateAvailableResponse> listenFirmwareUpdates($0.StreamRequest request, {$grpc.CallOptions? options}) {
  return $createStreamingCall(_$listenFirmwareUpdates, $async.Stream.fromIterable([request]), options: options);
}

// services/grpc_service.dart
class GrpcService {
  final ClientChannel channel;

  GrpcService({required String host, required int port})
      : channel = ClientChannel(
          host,
          port: port,
          options: const ChannelOptions(
          // 本番環境ではセキュアな接続を使用
            credentials: ChannelCredentials.insecure(),
          ),
        );

  // 既存のメソッド...

  // ファームウェア更新のリッスン用メソッドを追加
  Stream<FirmwareUpdateAvailableResponse> listenFirmwareUpdates(
      int userId) async* {
    final headers = await headersProvider();
    final client = NotificationServiceClient(channel,
        options: CallOptions(
          metadata: headers,
        ));
    final request = StreamRequest()..userId = userId;
    yield* client.listenFirmwareUpdates(request);
  }
}

// services/grpc_service.dart
final firmwareUpdateProvider =
    StreamProvider<FirmwareUpdateAvailableResponse>((ref) {
  final grpcService = ref.watch(grpcServiceProvider);

  final user = ref.read(userProvider);
  if (user?.uid == null) {
    return const Stream.empty();
  }
  return grpcService.listenFirmwareUpdates(user!.id!);
});

// lib/screens/home/home_tab.dart

import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';

class HomeTab extends ConsumerStatefulWidget {
  const HomeTab({super.key});

  @override
  _HomeTabState createState() => _HomeTabState();
}

class _HomeTabState extends ConsumerState<HomeTab> {
  
  @override
  Widget build(BuildContext context) {
    final firmwareUpdateAsyncValue = ref.watch(firmwareUpdateProvider);

    return DebugContainer(
      child: Center(
        child: firmwareUpdateAsyncValue.when(
          data: (response) {
            if (response.message == "NEW_FIRMWARE_AVAILABLE") {
              return Text("新しいファームウェア（${response.newFirmwareVersion}）がダウンロード可能です");
            } else {
              // ファームウェアが最新の場合、何も表示しない
              return SizedBox.shrink();
            }
          },
          loading: () => CircularProgressIndicator(),
          error: (error, stack) => Text("エラーが発生しました: $error"),
        ),
      ),
    );
  }
}

clocky_api_local  | 2024/04/10 10:57:37 received listen firmware update request from user: XXXXXXXXXXXXXXXXXXXXXX
clocky_api_local  | 2024/04/10 10:57:38 sent message to user: 1