Rework to use KUKSA.val databroker gRPC API

Rework to move from the WebSocket API with the older KUKSA.val
server to the gRPC "VAL" API of the databroker.

Changes include:
- All VISS WebSocket API code has been removed, and the signal
  providers replumbed to be driven by a new VssClient class with
  a homescreen-specific child class to hold all the gRPC API
  handling.
- The generated code for the VAL API and its dependencies has
  been checked in under lib/generated, as there still does not
  seem to be a good way to generate it during the Flutter build.
- The configuration file is now expected to be "homescreen.yaml"
  instead of "homescreen_config.yaml".  The authorization token
  field name has been renamed to "authorization", and there are
  new "use-tls" and "ca-certificate" configuration fields.  TLS
  is disabled by default for now, and the default CA certificate
  is /etc/kuksa.val/CA.pem.
- Updated .gitignore to cover a couple of generated files that
  weren't included.

Bug-AGL: SPEC-4762, SPEC-4903

Signed-off-by: Scott Murray <scott.murray@konsulko.com>
Change-Id: I1b95ed27a72435364d54ec846f2be88e3d8bb092

1 files changed, 90 insertions, 97 deletions

diff --git a/lib/config.dart b/lib/config.dart
index 6da02ed..d3e3936 100644
--- a/lib/config.dart
+++ b/lib/config.dart
@@ -1,115 +1,108 @@
 // SPDX-License-Identifier: Apache-2.0
 import 'dart:io';
-import 'package:flutter/material.dart';
+import 'package:flutter/foundation.dart';
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:yaml/yaml.dart';
 
-import 'vehicle-signals/viss_connection_widget.dart';
+class KuksaConfig {
+  final String hostname;
+  final int port;
+  final String authorization;
+  final bool use_tls;
+  final List<int> ca_certificate;
+  final String tls_server_name;
 
-class GetConfig extends ConsumerStatefulWidget {
-  const GetConfig({Key? key, required this.client}) : super(key: key);
-  final HttpClient client;
+  static String configFilePath = '/etc/xdg/AGL/homescreen.yaml';
+  static String defaultHostname = 'localhost';
+  static int defaultPort = 55555;
+  static String defaultCaCertPath = '/etc/kuksa-val/CA.pem';
 
-  @override
-  ConsumerState<GetConfig> createState() => _GetConfigState();
+  KuksaConfig({required this.hostname, required this.port, required this.authorization,
+    required this.use_tls, required this.ca_certificate, required this.tls_server_name});
 }
 
-class _GetConfigState extends ConsumerState<GetConfig> {
-  @override
-  void initState() {
-    super.initState();
-    WidgetsBinding.instance.addPostFrameCallback((timeStamp) {
-      final configStateProvider = ref.read(ConfigStateprovider.notifier);
+// NOTE: This may need to be changed to a FutureProvider to avoid slowing
+//       down the top-level widget initState...
 
-      String configFilePath = '/etc/xdg/AGL/homescreen_config.yaml';
+final kuksaConfigProvider = Provider((ref) {
+  final configFile = File(KuksaConfig.configFilePath);
+  try {
+    print("Reading configuration ${KuksaConfig.configFilePath}");
+    String content = configFile.readAsStringSync();
+    final dynamic yamlMap = loadYaml(content);
 
-      final configFile = File(configFilePath);
-      configFile.readAsString().then((content) {
-        final dynamic yamlMap = loadYaml(content);
-        configStateProvider.update(
-          read: true,
-          hostname: yamlMap['hostname'],
-          port: yamlMap['port'],
-          kuksaAuthToken: yamlMap['kuskaAuthToken'],
-        );
-      }).catchError((content) {
-        configStateProvider.update(read: true);
-      });
-    });
-  }
+    String hostname = KuksaConfig.defaultHostname;
+    if (yamlMap.containsKey('hostname')) {
+      hostname = yamlMap['hostname'];
+    }
 
-  @override
-  Widget build(BuildContext context) {
-    final config = ref.watch(ConfigStateprovider);
-    if (!config.read) {
-      return Container(
-          child: const Text("Reading configuration file!",
-              style: TextStyle(
-                  fontSize: 20,
-                  fontWeight: FontWeight.bold,
-                  color: Colors.white)));
-    } else if (config.hostname == "" ||
-        config.port == 0 ||
-        config.kuksaAuthToken == "") {
-      return Container(
-          child: const Text("Invalid configuration file!",
-              style: TextStyle(
-                  fontSize: 20,
-                  fontWeight: FontWeight.bold,
-                  color: Colors.white)));
+    int port = KuksaConfig.defaultPort;
+    if (yamlMap.containsKey('port')) {
+      port = yamlMap['port'];
     }
-    return VISServerConnectionWidget(client: widget.client);
-  }
-}
 
-class Config {
-  Config({
-    required this.read,
-    required this.hostname,
-    required this.port,
-    required this.kuksaAuthToken,
-  });
-  final bool read;
-  final String hostname;
-  final int port;
-  final String kuksaAuthToken;
+    String token = "";
+    if (yamlMap.containsKey('authorization')) {
+      String s = yamlMap['authorization'];
+      if (s.isNotEmpty) {
+        if (s.startsWith("/")) {
+          debugPrint("Reading authorization token $s");
+          try {
+            token = File(s).readAsStringSync();
+          } on Exception catch(_) {
+            print("ERROR: Could not read authorization token file $token");
+            token = "";
+          }
+        } else {
+          token = s;
+        }
+      }
+    }
+    //debugPrint("authorization = $token");
 
-  Config copywith({
-    bool? read,
-    String? hostname,
-    int? port,
-    String? kuksaAuthToken,
-  }) =>
-      Config(
-        read: read ?? this.read,
-        hostname: hostname ?? this.hostname,
-        port: port ?? this.port,
-        kuksaAuthToken: kuksaAuthToken ?? this.kuksaAuthToken,
-      );
-}
+    bool use_tls = false;
+    if (yamlMap.containsKey('use-tls')) {
+      var value = yamlMap['use-tls'];
+      if (value is bool)
+        use_tls = value;
+    }
+    //debugPrint("Use TLS = $use_tls");
+
+    List<int> ca_cert = [];
+    String ca_path = KuksaConfig.defaultCaCertPath;
+    if (yamlMap.containsKey('ca-certificate')) {
+      ca_path = yamlMap['ca-certificate'];
+    }
+    try {
+      ca_cert = File(ca_path).readAsBytesSync();
+    } on Exception catch(_) {
+      print("ERROR: Could not read CA certificate file $ca_path");
+      ca_cert = [];
+    }
+    //debugPrint("CA cert = $ca_cert");
 
-final ConfigStateprovider = StateNotifierProvider<ConfigStateNotifier, Config>(
-    (ref) => ConfigStateNotifier());
+    String tls_server_name = "";
+    if (yamlMap.containsKey('tls-server-name')) {
+      tls_server_name = yamlMap['tls_server_name'];
+    }
 
-class ConfigStateNotifier extends StateNotifier<Config> {
-  ConfigStateNotifier() : super(_initialValue);
-  static final Config _initialValue = Config(
-    read: false,
-    hostname: "",
-    port: 0,
-    kuksaAuthToken: "",
-  );
-  void update({
-    bool? read,
-    String? hostname,
-    int? port,
-    String? kuksaAuthToken,
-  }) {
-    state = state.copywith(
-      read: read,
-      hostname: hostname,
-      port: port,
-      kuksaAuthToken: kuksaAuthToken,
-    );
+    return KuksaConfig(
+          hostname: hostname,
+          port: port,
+          authorization: token,
+          use_tls: use_tls,
+          ca_certificate: ca_cert,
+          tls_server_name: tls_server_name
+        );
+  } on Exception catch(_) {
+    return KuksaConfig(
+          hostname: KuksaConfig.defaultHostname,
+          port: KuksaConfig.defaultPort,
+          authorization: "",
+          use_tls: false,
+          ca_certificate: [],
+          tls_server_name: ""
+        );
   }
-}
+});
+