init commit

Author: mth-dwarf

lib/data/local/event_storage.dart

@@ -24,7 +24,7 @@ class EventStorage {
 
   Future<void> addEvent(TrackEvent event) async {
     await _queue(callback: () async {
-      final cachedEvents = await readCache();
+      final cachedEvents = await getCachedEvents();
       cachedEvents.add(event);
       final json = cachedEvents.map((e) => e.toJson()).toList();
       await _writeToFile(jsonEncode(json));
@@ -33,15 +33,15 @@ class EventStorage {
 
   Future<void> removeEvents(List<TrackEvent> events) async {
     await _queue(callback: () async {
-      final cache = await readCache();
+      final cache = await getCachedEvents();
       final remaining =
           cache.where((event) => !events.contains(event)).toList();
       final json = remaining.map((e) => e.toJson()).toList();
       await _writeToFile(jsonEncode(json));
     });
   }
 
-  Future<List<TrackEvent>> readCache() async {
+  Future<List<TrackEvent>> getCachedEvents() async {
     final file = File(_storagePath);
     final content = await file.readAsString();
     if (content.isEmpty) return [];

lib/data/tracking_exceptions.dart

@@ -1,3 +1,17 @@
-abstract class TrackingException {}
+abstract class TrackingException {
+  final String message;
 
-final class TrackingTimeoutException {}
+  TrackingException({required this.message});
+}
+
+final class TrackingTimeoutException extends TrackingException {
+  TrackingTimeoutException() : super(message: "Local caching timed out");
+}
+
+final class TrackingNotInitialisedException extends TrackingException {
+  TrackingNotInitialisedException()
+      : super(
+          message:
+              "Plugin not initialised. Remember to call initialize() after instantiation.",
+        );
+}

lib/data/utils.dart

@@ -1,9 +1 @@
-import 'dart:io';
-
 typedef Json = Map<String, dynamic>;
-
-Future<File> createFile(String path) async {
-  final file = File(path);
-  await file.create(recursive: true);
-  return file;
-}

lib/domain/event_tracker/event_tracker.dart

@@ -30,40 +30,34 @@ class PageTimeTracker extends RouteObserver {
       }
 
       _addTime(routePath);
-
-      print(
-          "qqq time for $routePath=${_pageTimes[routePath]!.toDouble() / (1000)}");
     }
   }
 
   @override
   void didPush(Route route, Route? previousRoute) {
-    print("qqq didPush");
     _trackRouteTime(previousRoute);
+    super.didPush(route, previousRoute);
   }
 
   @override
   void didPop(Route route, Route? previousRoute) {
-    print("qqq didPop");
     _trackRouteTime(route);
+    super.didPop(route, previousRoute);
   }
 
   @override
   void didRemove(Route route, Route? previousRoute) {
-    print("qqq didRemove");
     _trackRouteTime(route);
     super.didRemove(route, previousRoute);
   }
 
   @override
   void didChangeTop(Route topRoute, Route? previousTopRoute) {
-    print("qqq didChangeTop");
     _trackRouteTime(previousTopRoute);
   }
 
   @override
   void didReplace({Route? newRoute, Route? oldRoute}) {
-    print("qqq didReplace");
     _trackRouteTime(oldRoute);
   }
 

lib/domain/route_time_tracker/page_time_tracker.dart

@@ -1,28 +1,37 @@
 import 'package:tracking/data/local/event_storage.dart';
 import 'package:tracking/data/remote/tracking_client.dart';
+import 'package:tracking/data/tracking_exceptions.dart';
 import 'package:tracking/domain/event_tracker/track_event.dart';
 
 class Tracker {
   final _eventStorage = EventStorage();
   final TrackingClient _trackingClient;
   final int batchSize;
+  bool isInitialised = false;
 
   Tracker({required String serviceBaseUrl, this.batchSize = 5})
       : _trackingClient = TrackingClient(serviceBaseUrl);
 
   Future<void> initialize() async {
     await _eventStorage.init();
+    isInitialised = true;
+    await sendAll();
   }
 
   Future<void> track(TrackEvent event) async {
+    if (!isInitialised) throw TrackingNotInitialisedException();
     await _eventStorage.addEvent(event);
-    final cachedEvents = await _eventStorage.readCache();
-    print("qqq events = ${cachedEvents.length}");
-    if (cachedEvents.length > batchSize - 1) {
+    final cachedEvents = await _eventStorage.getCachedEvents();
+    if (cachedEvents.length >= batchSize) {
       await _trackingClient.sendMultipleEvents(cachedEvents);
       await _eventStorage.removeEvents(cachedEvents);
-      final rem = await _eventStorage.readCache();
-      print("qqq events = ${rem.length}");
     }
   }
+
+  Future<void> sendAll() async {
+    if (!isInitialised) throw TrackingNotInitialisedException();
+    final cachedEvents = await _eventStorage.getCachedEvents();
+    await _trackingClient.sendMultipleEvents(cachedEvents);
+    await _eventStorage.removeEvents(cachedEvents);
+  }
 }