[Flutter × Go × gRPC] Implementation of forced application update function (screen lock)

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

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

message StreamRequest {
  int32 userId = 1; // user id
  string current_app_version = 2; // 現在のアプリバージョン
}

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

message AppUpdate {
  int32 userId = 1;
  string message = 2;
  string min_supported_version = 3; // 利用可能な最小バージョン
}

message UpdateVersionResponse {
  optional FirmwareUpdate firmware_update = 1;
  optional AppUpdate app_update = 2;
}

service NotificationService {
  rpc ListenUpdates(stream StreamRequest) returns (stream UpdateVersionResponse);
}

$ protoc --proto_path=protos --go_out=pb --go_opt=paths=source_relative --go-grpc_out=pb --go-grpc_opt=paths=source_relative protos/notification.proto

// grpc_notification_service.go
package clocky_be

import (
	"context"
	"log"
	"time"

	"github.com/EarEEG-dev/clocky_be/pb"
	"github.com/jmoiron/sqlx"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
)

// Notification Service Server
type notificationServiceServer struct {
	pb.UnimplementedNotificationServiceServer
	db      *sqlx.DB
	sm      *IotShadowManager
	ssm     *SSMClient
	sqsChan *SQSChannel
}

func (s *notificationServiceServer) ListenUpdates(stream pb.NotificationService_ListenUpdatesServer) error {
	uid, ok := stream.Context().Value("uid").(string)
	if !ok {
		return status.Errorf(codes.Unauthenticated, "uid not found in context")
	}

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

	for {
		req, err := stream.Recv()
		if err != nil {
			return status.Errorf(codes.Internal, "Error receiving stream request: %v", err)
		}

		userId := req.UserId

		// DBからユーザー情報を取得する
		user, err := GetUser(s.db, uid)
		if err != nil {
			return err
		}

		currentAppVersion := req.CurrentAppVersion
		currentFirmwareVersion := user.FirmwareVersion

		// ファームウェア更新チェック
		firmwareUpdate := s.checkFirmwareUpdate(userId, currentFirmwareVersion)
		// アプリ更新チェック
		appUpdate := s.checkAppUpdate(userId, currentAppVersion)

		response := &pb.UpdateVersionResponse{}

		if firmwareUpdate != nil {
			response.FirmwareUpdate = firmwareUpdate
		}

		if appUpdate != nil {
			response.AppUpdate = appUpdate
		}

		if err := stream.Send(response); err != nil {
			return status.Errorf(codes.Internal, "Error sending stream response: %v", err)
		}

		time.Sleep(time.Minute)

		select {
		case <-stream.Context().Done():
			// ストリームがキャンセルされた場合はループを抜ける
			log.Printf("stream closed by client")
			return stream.Context().Err()
		default:
			// ループを続ける
		}
	}
}

func (s *notificationServiceServer) checkFirmwareUpdate(userId int32, currentFirmwareVersion string) *pb.FirmwareUpdate {
	// SSMパラメータストアから最新バージョンを取得する
	newFirmwareVersion, err := s.ssm.GetNewFirmwareVersion(context.Background())
	if err != nil {
		log.Printf("failed to get new firmware version: %v", err)
		return nil
	}

	if newFirmwareVersion != currentFirmwareVersion {
		return &pb.FirmwareUpdate{
			UserId:             userId,
			Message:            "New firmware available",
			NewFirmwareVersion: newFirmwareVersion,
		}
	}

	return nil
}

func (s *notificationServiceServer) checkAppUpdate(userId int32, currentAppVersion string) *pb.AppUpdate {
    minSupportedVersion := "0.5.4" // この値はデータベースや設定ファイルから取得
    if currentAppVersion < minSupportedVersion {
        return &pb.AppUpdate{
            UserId:             userId,
            Message:            "App update required",
            MinSupportedVersion: minSupportedVersion,
        }
    }
    return nil
}

$ flutter pub add package_info_plus
$ flutter pub get

// lib/services/grpc_service.dart
final grpcStreamProvider = StreamProvider((ref) async* {
  final grpcService = ref.watch(grpcServiceProvider);
  final user = ref.read(userProvider);
  if (user?.uid == null) {
    yield* const Stream.empty();
    return;
  }

  // Get the current app version
  final packageInfo = await PackageInfo.fromPlatform();
  final currentAppVersion = packageInfo.version;

  // Pass the current app version to the gRPC service
  yield* grpcService.listenNotifications(user!.id!, currentAppVersion);
});

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

// lib/services/grpc_service.dart
Stream listenUpdates(
    int userId, String currentAppVersion) async* {
  while (true) {
    try {
      final headers = await headersProvider();
      final client = NotificationServiceClient(channel,
          options: CallOptions(
            metadata: headers,
          ));
      final request = StreamRequest()
        ..userId = userId
        ..currentAppVersion = currentAppVersion;
      final requestStream = Stream.fromIterable([request]);
      await for (var response in client.listenUpdates(requestStream)) {
        yield response;
        print("listenUpdates response: $response");
      }
    } catch (e) {
      print('Error listening to updates: $e');
      yield* Stream.error(e);
      await Future.delayed(const Duration(seconds: 5));
      print('listenUpdates reconnect...');
    }
  }
}

print("listenUpdates response: $response");

flutter: listenUpdates response: firmwareUpdate: {
  userId: 20
  message: New firmware available
  newFirmwareVersion: 0.1.14
}
appUpdate: {
  userId: 20
  message: App update required
  minSupportedVersion: 0.5.4
}

// lib/screens/home/home_tab.dart
final notificationShownProvider = StateProvider((ref) => false);

// lib/screens/home/home_tab.dart
updateVersionResponse.when(
  data: (response) {
    bool isNotificationShown = notificationShown;

    // アプリのアップデートが必要な場合、画面をロックしてモーダル表示
    if (!isNotificationShown &&
        response.appUpdate.minSupportedVersion.isNotEmpty) {
      WidgetsBinding.instance.addPostFrameCallback((_) {
        showDialog(
          context: context,
          barrierDismissible: false,
          builder: (BuildContext context) {
            return AlertDialog(
              title: const Text('アプリのアップデートが必要です'),
              content: Text(
                  'バージョン ${response.appUpdate.minSupportedVersion} 以上に更新してください。'),
              actions: [
                TextButton(
                  onPressed: () {
                    // アプリストアへ遷移
                    launchAppStore();
                  },
                  child: const Text(
                    "今すぐ更新する",
                    style: TextStyle(
                      color: AppColors.primaryColorDark,
                      fontWeight: FontWeight.bold,
                    ),
                  ),
                ),
              ],
            );
          },
        );
        ref.read(notificationShownProvider.notifier).state = true;
      });
      isNotificationShown = true;
    }

    // ファームウェアアップデートの通知
    if (!isNotificationShown &&
        response.firmwareUpdate.newFirmwareVersion.isNotEmpty) {
      WidgetsBinding.instance.addPostFrameCallback((_) {
        if (!notificationShown) {
          showCustomMessageBar(
            context: context,
            message:
                "新しいファームウェアバージョン（${response.firmwareUpdate.newFirmwareVersion}）がダウンロード可能です。",
            onClose: () {},
            onTapped: () {
              showDialog(
                context: navigatorKey.currentState!.context,
                builder: (BuildContext context) {
                  return FirmwareUpdateDialog(
                    newVersion: response.firmwareUpdate.newFirmwareVersion,
                    onConfirm: () {
                      final userNotifier = ref.read(userProvider.notifier);
                      userNotifier.updateUser(User(
                          firmwareVersion:
                              response.firmwareUpdate.newFirmwareVersion));
                    },
                    onCancel: () {},
                  );
                },
              );
            },
            duration: Duration.zero,
          );
          ref.read(notificationShownProvider.notifier).state = true;
        }
      });
      isNotificationShown = true;
    }

    return const SizedBox.shrink();
  },
  loading: () => const CircularProgressIndicator(),
  error: (error, stack) {
    WidgetsBinding.instance.addPostFrameCallback((_) {
      ScaffoldMessenger.of(context).showSnackBar(
        const SnackBar(
          content: Text("サーバーに再接続中・・・"),
          duration: Duration(seconds: 3),
        ),
      );
    });
    return const SizedBox.shrink();
  },
),

// lib/screens/home/home_tab.dart
Future launchAppStore() async {
  const String appId = String.fromEnvironment('appId');
  const String appleId = String.fromEnvironment('appleId');

  const String googlePlayUrl =
      'https://play.google.com/store/apps/details?id=$appId';
  const String appStoreUrl = 'https://apps.apple.com/app/id$appleId';

  final url = defaultTargetPlatform == TargetPlatform.iOS
      ? appStoreUrl
      : googlePlayUrl;

  if (await canLaunchUrl(Uri.parse(url))) {
    print(Uri.parse(url));
    await launchUrl(Uri.parse(url));
  } else {
    throw 'Could not launch $url';
  }
}

flutter: current App version 0.5.2