feat: Events review (#228)

* Improved events filtering time and improved the time that the events are loaded and showed to the user; and
* Redesigned the events screen on small screens. This addresses the issue that blocked the UI until all the events were loaded; and
* The devices selection is persisted across app sessions (#177)

Author: bdlukaa

lib/l10n/app_en.arb

@@ -317,6 +317,14 @@
   },
   "noRecords": "This camera has no records in the current period.",
   "filter": "Filter",
+  "loadEvents": "{n, plural, =0{Load} =1{Load from 1 device} other{Load from {n} devices}}",
+  "@loadEvents": {
+    "placeholders": {
+      "n": {
+        "type": "int"
+      }
+    }
+  },
   "timeFilter": "Time filter",
   "fromDate": "From",
   "toDate": "To",

lib/l10n/app_fr.arb

@@ -295,6 +295,14 @@
   },
   "noRecords": "Cette caméra n'a aucun enregistrement dans la période actuelle",
   "filter": "Filtre",
+  "loadEvents": "{n, plural, =0{Load} =1{Load from 1 device} other{Load from {n} devices}}",
+  "@loadEvents": {
+    "placeholders": {
+      "n": {
+        "type": "int"
+      }
+    }
+  },
   "timeFilter": "Filtre par temps",
   "fromDate": "De",
   "toDate": "À",

lib/l10n/app_pl.arb

@@ -317,6 +317,14 @@
   },
   "noRecords": "Ta kamera nie ma nagrań w tym zakresie.",
   "filter": "Filtr",
+  "loadEvents": "{n, plural, =0{Load} =1{Load from 1 device} other{Load from {n} devices}}",
+  "@loadEvents": {
+    "placeholders": {
+      "n": {
+        "type": "int"
+      }
+    }
+  },
   "timeFilter": "Filtr czasu",
   "fromDate": "Od",
   "toDate": "Do",

lib/l10n/app_pt.arb

@@ -317,6 +317,14 @@
   },
   "noRecords": "Essa câmera não tem gravações neste período.",
   "filter": "Filtrar",
+  "loadEvents": "{n, plural, =0{Buscar} =1{Buscar de 1 dispositivo} other{Buscar de {n} dispositivos}}",
+  "@loadEvents": {
+    "placeholders": {
+      "n": {
+        "type": "int"
+      }
+    }
+  },
   "timeFilter": "Filtro de tempo",
   "fromDate": "De",
   "toDate": "à",

lib/main.dart

@@ -30,7 +30,7 @@ import 'package:bluecherry_client/models/layout.dart';
 import 'package:bluecherry_client/models/server.dart';
 import 'package:bluecherry_client/providers/desktop_view_provider.dart';
 import 'package:bluecherry_client/providers/downloads_provider.dart';
-import 'package:bluecherry_client/providers/events_playback_provider.dart';
+import 'package:bluecherry_client/providers/events_provider.dart';
 import 'package:bluecherry_client/providers/home_provider.dart';
 import 'package:bluecherry_client/providers/mobile_view_provider.dart';
 import 'package:bluecherry_client/providers/server_provider.dart';
@@ -168,8 +168,8 @@ Future<void> main(List<String> args) async {
       MobileViewProvider.ensureInitialized(),
       DesktopViewProvider.ensureInitialized(),
       ServersProvider.ensureInitialized(),
-      EventsProvider.ensureInitialized(),
       UpdateManager.ensureInitialized(),
+      EventsProvider.ensureInitialized(),
     ]);
 
     /// Firebase messaging isn't available on windows nor linux
@@ -295,15 +295,15 @@ class _UnityAppState extends State<UnityApp>
         ChangeNotifierProvider<ServersProvider>.value(
           value: ServersProvider.instance,
         ),
-        ChangeNotifierProvider<EventsProvider>.value(
-          value: EventsProvider.instance,
-        ),
         ChangeNotifierProvider<UpdateManager>.value(
           value: UpdateManager.instance,
         ),
         ChangeNotifierProvider<UnityPlayers>.value(
           value: UnityPlayers.instance,
         ),
+        ChangeNotifierProvider<EventsProvider>.value(
+          value: EventsProvider.instance,
+        ),
       ],
       child: Consumer<SettingsProvider>(
         builder: (context, settings, _) => MaterialApp(

lib/models/device.dart

@@ -76,7 +76,8 @@ class Device {
   /// [Uri] to the RTSP stream associated with the device.
   final int id;
 
-  /// `true` [status] indicates that device device is working correctly or is `Online`.
+  /// `true` [status] indicates that device device is working correctly or is
+  /// `Online`.
   final bool status;
 
   /// Horizontal resolution of the device device.

lib/providers/events_playback_provider.dart

@@ -0,0 +1,172 @@
+/*
+ * This file is a part of Bluecherry Client (https://github.com/bluecherrydvr/unity).
+ *
+ * Copyright 2022 Bluecherry, LLC
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import 'package:bluecherry_client/api/api.dart';
+import 'package:bluecherry_client/models/event.dart';
+import 'package:bluecherry_client/models/server.dart';
+import 'package:bluecherry_client/providers/app_provider_interface.dart';
+import 'package:bluecherry_client/providers/server_provider.dart';
+import 'package:bluecherry_client/screens/events_browser/filter.dart';
+import 'package:bluecherry_client/utils/constants.dart';
+import 'package:bluecherry_client/utils/storage.dart';
+import 'package:flutter/foundation.dart';
+
+typedef EventsData = Map<Server, List<Event>>;
+
+class LoadedEvents {
+  final EventsData events;
+  final List<Server> invalidResponses;
+
+  factory LoadedEvents() {
+    return LoadedEvents.raw(
+      events: {},
+      invalidResponses: List.empty(growable: true),
+    );
+  }
+
+  const LoadedEvents.raw({
+    required this.events,
+    required this.invalidResponses,
+  });
+
+  List<Event> get filteredEvents => events.values.expand((e) => e).toList();
+}
+
+class EventsProvider extends UnityProvider {
+  EventsProvider._();
+
+  static late final EventsProvider instance;
+  static Future<EventsProvider> ensureInitialized() async {
+    instance = EventsProvider._();
+    await instance.initialize();
+    debugPrint('EventsProvider initialized');
+    return instance;
+  }
+
+  Set<String> selectedDevices = {};
+  void toggleDevice(String device) {
+    if (selectedDevices.contains(device)) {
+      selectedDevices.remove(device);
+    } else {
+      selectedDevices.add(device);
+    }
+    save();
+  }
+
+  void selectDevices(Iterable<String> devices) {
+    selectedDevices.addAll(devices);
+    save();
+  }
+
+  void unselectDevices(Iterable<String> devices) {
+    selectedDevices.removeAll(devices);
+    save();
+  }
+
+  DateTime? startTime, endTime;
+  EventsMinLevelFilter _levelFilter = EventsMinLevelFilter.any;
+  EventsMinLevelFilter get levelFilter => _levelFilter;
+  set levelFilter(EventsMinLevelFilter value) {
+    _levelFilter = value;
+    notifyListeners();
+  }
+
+  LoadedEvents? loadedEvents;
+
+  @override
+  Future<void> initialize() async {
+    await tryReadStorage(() => initializeStorage(events, kStorageEvents));
+  }
+
+  @override
+  Future<void> save({bool notifyListeners = true}) async {
+    try {
+      await events.write({
+        kStorageEvents: kStorageEvents,
+        'selectedDevices': selectedDevices.toList(),
+      });
+    } catch (error, stackTrace) {
+      debugPrint('Failed to save events:\n $error\n$stackTrace');
+    }
+
+    super.save(notifyListeners: notifyListeners);
+  }
+
+  @override
+  Future<void> restore({bool notifyListeners = true}) async {
+    final data = await tryReadStorage(() => events.read());
+
+    selectedDevices = (data['selectedDevices'] as List).toSet().cast<String>();
+
+    super.restore(notifyListeners: notifyListeners);
+  }
+
+  void _notify() => notifyListeners();
+}
+
+extension EventsScreenProvider on EventsProvider {
+  Future<void> loadEvents() async {
+    loadedEvents = LoadedEvents();
+    _notify();
+
+    // Load the events at the same time
+    await Future.wait(ServersProvider.instance.servers.map((server) async {
+      if (!server.online || server.devices.isEmpty) return;
+
+      server = await API.instance.checkServerCredentials(server);
+
+      try {
+        final allowedDevices = server.devices
+            .where((d) => d.status && selectedDevices.contains(d.streamURL));
+
+        // Perform a query for each selected device
+        await Future.wait(allowedDevices.map((device) async {
+          final iterable = (await API.instance.getEvents(
+            server,
+            startTime: startTime,
+            endTime: endTime,
+            device: device,
+          ))
+              .toList()
+            ..removeWhere((event) {
+              switch (levelFilter) {
+                case EventsMinLevelFilter.alarming:
+                  if (event.isAlarm) return true;
+                  break;
+                case EventsMinLevelFilter.warning:
+                  if (event.priority == EventPriority.warning) return true;
+                  break;
+                default:
+                  break;
+              }
+              return false;
+            });
+
+          loadedEvents!.events[server] ??= [];
+          loadedEvents!.events[server]!.addAll(iterable);
+          _notify();
+        }));
+      } catch (exception, stacktrace) {
+        debugPrint(exception.toString());
+        debugPrint(stacktrace.toString());
+        loadedEvents!.invalidResponses.add(server);
+      }
+    }));
+  }
+}