convert hive boxes to lazy boxes after first load to save ram

Codel1417 · Codel1417 · commit 2b203a1ac295 · 2026-04-06T02:10:57.000-04:00
diff --git a/lib/Backend/Bluetooth/known_devices.dart b/lib/Backend/Bluetooth/known_devices.dart
@@ -4,6 +4,7 @@ import 'dart:io';
 import 'package:built_collection/built_collection.dart';
 import 'package:flutter/foundation.dart';
 import 'package:flutter_foreground_task/flutter_foreground_task.dart';
+import 'package:hive_ce/hive.dart';
 import 'package:logging/logging.dart' as log;
 import 'package:wakelock_plus/wakelock_plus.dart';
 
@@ -23,8 +24,13 @@ class KnownDevices with ChangeNotifier {
   static final KnownDevices instance = KnownDevices._internal();
 
   KnownDevices._internal() {
-    BuiltList<BaseStoredDevice> storedDevices =
-        HiveProxy.getAll<BaseStoredDevice>(devicesBox).toBuiltList();
+    BuiltList<BaseStoredDevice> storedDevices = Hive.box<BaseStoredDevice>(
+      devicesBox,
+    ).values.toBuiltList();
+
+    // after all device entries are loaded, close the box. The box will be
+    // re-opened as a lazy box to save ram
+    Hive.box<BaseStoredDevice>(devicesBox).close();
     Map<String, BaseStatefulDevice> results = {};
     try {
       if (storedDevices.isNotEmpty) {
@@ -66,11 +72,10 @@ class KnownDevices with ChangeNotifier {
   }
 
   Future<void> store() async {
-    await HiveProxy.clear<BaseStoredDevice>(devicesBox);
-    await HiveProxy.addAll<BaseStoredDevice>(
-      devicesBox,
-      state.values.map((e) => e.baseStoredDevice),
-    );
+    LazyBox<BaseStoredDevice> lazyBox =
+        await Hive.openLazyBox<BaseStoredDevice>(devicesBox);
+    await lazyBox.clear();
+    await lazyBox.addAll(state.values.map((e) => e.baseStoredDevice));
     _notify();
   }
 
diff --git a/lib/Backend/audio.dart b/lib/Backend/audio.dart
@@ -3,6 +3,7 @@ import 'dart:io';
 import 'package:audioplayers/audioplayers.dart';
 import 'package:built_collection/built_collection.dart';
 import 'package:flutter/material.dart';
+import 'package:hive_ce/hive.dart';
 import 'package:logging/logging.dart';
 
 import '../constants.dart';
@@ -25,18 +26,20 @@ Future<void> playSound(String file) async {
 
 class UserAudioActions with ChangeNotifier {
   BuiltList<AudioAction> _state = BuiltList();
+
   BuiltList<AudioAction> get state => _state;
 
   static final UserAudioActions instance = UserAudioActions._internal();
 
   UserAudioActions._internal() {
-    List<AudioAction> results = [];
+    Iterable<AudioAction> results = [];
     try {
-      results = HiveProxy.getAll<AudioAction>(audioActionsBox).toList(growable: true);
+      results = Hive.box<AudioAction>(audioActionsBox).values;
     } catch (e, s) {
       _audioLogger.severe("Unable to load audio: $e", e, s);
     }
-    _state = results.build();
+    Hive.box<AudioAction>(audioActionsBox).close();
+    _state = results.toList().build();
   }
 
   Future<void> add(AudioAction action) async {
@@ -49,7 +52,9 @@ class UserAudioActions with ChangeNotifier {
   }
 
   Future<void> remove(AudioAction action) async {
-    _state = _state.rebuild((p0) => p0.removeWhere((element) => element.uuid == action.uuid));
+    _state = _state.rebuild(
+      (p0) => p0.removeWhere((element) => element.uuid == action.uuid),
+    );
     store();
   }
 
@@ -59,8 +64,11 @@ class UserAudioActions with ChangeNotifier {
 
   Future<void> store() async {
     _audioLogger.info("Storing Custom Audio");
-    await HiveProxy.clear<AudioAction>(audioActionsBox);
-    await HiveProxy.addAll<AudioAction>(audioActionsBox, _state);
+    LazyBox<AudioAction> lazyBox = await Hive.openLazyBox<AudioAction>(
+      audioActionsBox,
+    );
+    await lazyBox.clear();
+    await lazyBox.addAll(_state);
     notifyListeners();
   }
 }
diff --git a/lib/Backend/favorite_actions.dart b/lib/Backend/favorite_actions.dart
@@ -17,11 +17,16 @@ final _favoriteActionsLogger = Logger('Favorites');
 
 @HiveType(typeId: 13)
 @freezed
-abstract class FavoriteAction with _$FavoriteAction implements Comparable<FavoriteAction> {
+abstract class FavoriteAction
+    with _$FavoriteAction
+    implements Comparable<FavoriteAction> {
   const FavoriteAction._();
 
   @Implements<Comparable<FavoriteAction>>()
-  const factory FavoriteAction({@HiveField(1) required String actionUUID, @HiveField(2) required int id}) = _FavoriteAction;
+  const factory FavoriteAction({
+    @HiveField(1) required String actionUUID,
+    @HiveField(2) required int id,
+  }) = _FavoriteAction;
 
   @override
   int compareTo(other) {
@@ -32,17 +37,21 @@ abstract class FavoriteAction with _$FavoriteAction implements Comparable<Favori
 
 class FavoriteActions with ChangeNotifier {
   BuiltList<FavoriteAction> _state = BuiltList();
+
   BuiltList<FavoriteAction> get state => _state;
 
   static final FavoriteActions instance = FavoriteActions._internal();
 
   FavoriteActions._internal() {
     List<FavoriteAction> results = [];
     try {
-      results = HiveProxy.getAll<FavoriteAction>(favoriteActionsBox).toList(growable: true);
+      results = Hive.box<FavoriteAction>(
+        favoriteActionsBox,
+      ).values.toList(growable: true);
     } catch (e, s) {
       _favoriteActionsLogger.severe("Unable to load favorites: $e", e, s);
     }
+    Hive.box<FavoriteAction>(favoriteActionsBox).close();
     _state = results.toBuiltList();
   }
 
@@ -56,7 +65,9 @@ class FavoriteActions with ChangeNotifier {
   }
 
   Future<void> remove(BaseAction action) async {
-    _state = _state.rebuild((p0) => p0.removeWhere((element) => element.actionUUID == action.uuid));
+    _state = _state.rebuild(
+      (p0) => p0.removeWhere((element) => element.actionUUID == action.uuid),
+    );
     await store();
   }
 
@@ -66,8 +77,11 @@ class FavoriteActions with ChangeNotifier {
 
   Future<void> store() async {
     _favoriteActionsLogger.info("Storing favorites");
-    await HiveProxy.clear<FavoriteAction>(favoriteActionsBox);
-    await HiveProxy.addAll<FavoriteAction>(favoriteActionsBox, _state);
+    LazyBox<FavoriteAction> lazyBox = await Hive.openLazyBox<FavoriteAction>(
+      favoriteActionsBox,
+    );
+    await lazyBox.clear();
+    await lazyBox.addAll(_state);
     updateShortcuts(_state);
     // ignore: unused_result
     notifyListeners();
diff --git a/lib/Backend/logging_wrappers.dart b/lib/Backend/logging_wrappers.dart
@@ -1,56 +1,21 @@
 import 'package:hive_ce/hive.dart';
 import 'package:logarte/logarte.dart';
 
-import '../constants.dart';
-
 // ignore: library_private_types_in_public_api
 _HiveProxyImpl HiveProxy = _HiveProxyImpl();
-List<String> genericBoxes = [settings];
 
 class _HiveProxyImpl {
   Future<void> put<E>(String box, dynamic key, E value) {
-    logarte.database(
-      target: '$key',
-      value: '$value',
-      source: box,
-    );
-    if (genericBoxes.contains(box)) {
-      return Hive.box(box).put(key, value);
-    } else {
-      return Hive.box<E>(box).put(key, value);
-    }
+    logarte.database(target: '$key', value: '$value', source: box);
+    return Hive.box(box).put(key, value);
   }
 
-  Future<void> deleteKey<E>(String box, dynamic key) {
-    if (genericBoxes.contains(box)) {
-      return Hive.box(box).delete(key);
-    } else {
-      return Hive.box<E>(box).delete(key);
-    }
+  Future<void> deleteKey(String box, dynamic key) {
+    return Hive.box(box).delete(key);
   }
 
   E getOrDefault<E>(String box, dynamic key, {required E? defaultValue}) {
-    if (genericBoxes.contains(box)) {
-      return Hive.box(box).get(key, defaultValue: defaultValue)!;
-    } else {
-      return Hive.box<E>(box).get(key, defaultValue: defaultValue)!;
-    }
-  }
-
-  Future<int> clear<E>(String box) {
-    if (genericBoxes.contains(box)) {
-      return Hive.box(box).clear();
-    } else {
-      return Hive.box<E>(box).clear();
-    }
-  }
-
-  Future<Iterable<int>> addAll<E>(String name, Iterable<E> values) {
-    return Hive.box<E>(name).addAll(values);
-  }
-
-  Iterable<E> getAll<E>(String name) {
-    return Hive.box<E>(name).values;
+    return Hive.box(box).get(key, defaultValue: defaultValue)!;
   }
 }
 
diff --git a/lib/Backend/move_lists_backend.dart b/lib/Backend/move_lists_backend.dart
@@ -27,13 +27,38 @@ extension EasingTypeExtension on EasingType {
       case EasingType.linear:
         return SizedBox(
           width: 65,
-          child: Sparkline(data: const [0, 1], lineColor: Theme.of(context).colorScheme.outline, lineWidth: 5),
+          child: Sparkline(
+            data: const [0, 1],
+            lineColor: Theme.of(context).colorScheme.outline,
+            lineWidth: 5,
+          ),
         );
       case EasingType.cubic:
         return SizedBox(
           width: 65,
           child: Sparkline(
-            data: const [0.271, 0.488, 0.657, 0.784, 0.875, 0.936, 0.973, 0.992, 0.999, 1, 1.001, 1.008, 1.027, 1.064, 1.125, 1.216, 1.343, 1.512, 1.729, 2],
+            data: const [
+              0.271,
+              0.488,
+              0.657,
+              0.784,
+              0.875,
+              0.936,
+              0.973,
+              0.992,
+              0.999,
+              1,
+              1.001,
+              1.008,
+              1.027,
+              1.064,
+              1.125,
+              1.216,
+              1.343,
+              1.512,
+              1.729,
+              2,
+            ],
             lineColor: Theme.of(context).colorScheme.outline,
             lineWidth: 5,
           ),
@@ -98,7 +123,13 @@ class Move {
 
   Move();
 
-  Move.move({this.leftServo = 0, this.rightServo = 0, this.speed = 50, this.easingType = EasingType.linear, this.moveType = MoveType.move});
+  Move.move({
+    this.leftServo = 0,
+    this.rightServo = 0,
+    this.speed = 50,
+    this.easingType = EasingType.linear,
+    this.moveType = MoveType.move,
+  });
 
   Move.delay(this.time) {
     moveType = MoveType.delay;
@@ -133,11 +164,18 @@ class Move {
           moveType == other.moveType;
 
   @override
-  int get hashCode => leftServo.hashCode ^ rightServo.hashCode ^ speed.hashCode ^ time.hashCode ^ easingType.hashCode ^ moveType.hashCode;
+  int get hashCode =>
+      leftServo.hashCode ^
+      rightServo.hashCode ^
+      speed.hashCode ^
+      time.hashCode ^
+      easingType.hashCode ^
+      moveType.hashCode;
 }
 
 class MoveLists with ChangeNotifier {
   BuiltList<MoveList> _state = BuiltList();
+
   BuiltList<MoveList> get state => _state;
 
   static final MoveLists instance = MoveLists._internal();
@@ -150,10 +188,11 @@ class MoveLists with ChangeNotifier {
   void reload() {
     List<MoveList> results = [];
     try {
-      results = HiveProxy.getAll<MoveList>(sequencesBox).toList(growable: true);
+      results = Hive.box<MoveList>(sequencesBox).values.toList();
     } catch (e, s) {
       sequencesLogger.severe("Unable to load sequences: $e", e, s);
     }
+    Hive.box<MoveList>(sequencesBox).close();
     _state = results.toBuiltList();
   }
 
@@ -179,8 +218,9 @@ class MoveLists with ChangeNotifier {
 
   Future<void> store() async {
     sequencesLogger.info("Storing sequences");
-    await HiveProxy.clear<MoveList>(sequencesBox);
-    await HiveProxy.addAll<MoveList>(sequencesBox, _state);
+    LazyBox<MoveList> lazyBox = await Hive.openLazyBox<MoveList>(sequencesBox);
+    await lazyBox.clear();
+    await lazyBox.addAll(_state);
     notifyListeners();
   }
 }
diff --git a/lib/Backend/sensors.dart b/lib/Backend/sensors.dart
@@ -1426,7 +1426,7 @@ class TriggerList with ChangeNotifier {
   TriggerList._internal() {
     List<Trigger> results = [];
     try {
-      results = HiveProxy.getAll<Trigger>(triggerBox)
+      results = Hive.box<Trigger>(triggerBox).values
           .map((trigger) {
             Trigger trigger2 = Trigger.trigDef(
               TriggerDefinitionList.allTriggerDefinitions.firstWhere(
@@ -1441,6 +1441,7 @@ class TriggerList with ChangeNotifier {
     } catch (e, s) {
       sensorsLogger.severe("Unable to load stored triggers: $e", e, s);
     }
+    Hive.box<Trigger>(triggerBox).close();
     if (results.isEmpty) {
       TriggerDefinition triggerDefinition = TriggerDefinitionList
           .allTriggerDefinitions
@@ -1475,8 +1476,9 @@ class TriggerList with ChangeNotifier {
 
   Future<void> store() async {
     sensorsLogger.info("Storing triggers");
-    await HiveProxy.clear<Trigger>(triggerBox);
-    await HiveProxy.addAll<Trigger>(triggerBox, _state);
+    LazyBox<Trigger> lazyBox = await Hive.openLazyBox<Trigger>(triggerBox);
+    await lazyBox.clear();
+    await lazyBox.addAll(_state);
     notifyListeners();
     updateWearData(reason: "Trigger Added/Removed");
   }
diff --git a/lib/Frontend/pages/settings.dart b/lib/Frontend/pages/settings.dart
@@ -225,21 +225,6 @@ class _SettingsState extends State<Settings> {
                 },
               ),
             ),
-            /*           ListTile(
-            title: Text(convertToUwU(scanDemoGear())),
-            leading: const Icon(Icons.explore),
-            subtitle: Text(convertToUwU(scanDemoGearTip())),
-            trailing: Switch(
-              value: HiveProxy.getOrDefault(settings, showDemoGear, defaultValue: showDemoGearDefault),
-              onChanged: (bool value) async {
-                setState(
-                  () {
-                    HiveProxy.put(settings, showDemoGear, value);
-                  },
-                );
-              },
-            ),
-          ), */
             ListTile(
               title: Text(convertToUwU(settingsUwUToggleTitle())),
               leading: const Icon(Icons.explore),
diff --git a/lib/main.dart b/lib/main.dart
@@ -249,6 +249,8 @@ Future<void> initHive() async {
     Hive.registerAdapter(VersionAdapter());
   }
   await Hive.openBox(settings); // Do not set type here
+
+  // closed after first read, reloads as lazybox
   await Hive.openBox<Trigger>(triggerBox);
   await Hive.openBox<FavoriteAction>(favoriteActionsBox);
   await Hive.openBox<AudioAction>(audioActionsBox);
diff --git a/test/hive_proxy_integration_test.dart b/test/hive_proxy_integration_test.dart

Original file line number	Diff line number	Diff line change
`@@ -249,6 +249,8 @@ Future<void> initHive() async {`
`249`	`249`	`Hive.registerAdapter(VersionAdapter());`
`250`	`250`	`}`
`251`	`251`	`await Hive.openBox(settings); // Do not set type here`
	`252`	`+`
	`253`	`+ // closed after first read, reloads as lazybox`
`252`	`254`	`await Hive.openBox<Trigger>(triggerBox);`
`253`	`255`	`await Hive.openBox<FavoriteAction>(favoriteActionsBox);`
`254`	`256`	`await Hive.openBox<AudioAction>(audioActionsBox);`