Move all databases to the same isolate

commet/lib/cache/drift_file_cache.dart

@@ -1,16 +1,11 @@
 import 'dart:io';
-import 'dart:isolate';
-import 'dart:ui';
-
 import 'package:commet/cache/file_cache.dart';
 import 'package:commet/config/app_config.dart';
 import 'package:commet/config/build_config.dart';
 import 'package:commet/debug/log.dart';
+import 'package:commet/utils/database/multiple_database_server.dart';
 import 'package:commet/utils/rng.dart';
 import 'package:drift/drift.dart';
-import 'package:drift/isolate.dart';
-import 'package:drift/native.dart';
-import 'package:flutter/services.dart';
 import 'package:path/path.dart' as p;
 import 'package:path_provider/path_provider.dart';
 
@@ -147,41 +142,18 @@ class DriftFileCache implements FileCache {
 
     isInit = true;
 
-    var port = IsolateNameServer.lookupPortByName(DriftFileCache.isolateName);
-
-    var isolate = DriftIsolate.fromConnectPort(
-        port ?? (await createIsolate()).connectPort);
-
-    db = DriftFileCacheDatabase(await isolate.connect());
-    clean();
-  }
-
-  Future<DriftIsolate> createIsolate() async {
-    final token = RootIsolateToken.instance!;
-    var isolate = await DriftIsolate.spawn(() {
-      BackgroundIsolateBinaryMessenger.ensureInitialized(token);
-
-      return LazyDatabase(() async {
-        final dir = p.join(await AppConfig.getDatabasePath(), "app");
-        var directory = Directory(dir);
-        if (!await directory.exists()) {
-          await directory.create(recursive: true);
-        }
+    final dir = p.join(await AppConfig.getDatabasePath(), "app");
+    var directory = Directory(dir);
+    if (!await directory.exists()) {
+      await directory.create(recursive: true);
+    }
 
-        final file = File(p.join(dir, "app_data.db"));
-        return NativeDatabase(file);
-      });
-    }, isolateSpawn: DriftFileCache._spawn);
+    final file = File(p.join(dir, "app_data.db"));
 
-    IsolateNameServer.registerPortWithName(
-        isolate.connectPort, DriftFileCache.isolateName);
+    var connection = await DatabaseIsolate.connect(file.absolute.path);
+    db = DriftFileCacheDatabase(connection);
 
-    return isolate;
-  }
-
-  static Future<Isolate> _spawn<T>(
-      void Function(T message) entryPoint, T message) {
-    return Isolate.spawn(entryPoint, message, debugName: "File Cache Isolate");
+    clean();
   }
 
   @override

commet/lib/client/matrix/database/matrix_database_io.dart

@@ -1,26 +1,26 @@
 import 'dart:io';
-import 'dart:isolate';
-import 'dart:ui';
 
 import 'package:commet/config/app_config.dart';
 import 'package:commet/diagnostic/diagnostics.dart';
-import 'package:drift/drift.dart';
-import 'package:drift/isolate.dart';
-import 'package:flutter/services.dart';
+import 'package:commet/utils/database/multiple_database_server.dart';
 import 'package:matrix/matrix.dart';
 import 'package:matrix_dart_sdk_drift_db/matrix_dart_sdk_drift_db.dart';
 import 'package:path/path.dart' as p;
-// ignore: depend_on_referenced_packages
-import 'package:drift/native.dart';
 
 Future<DatabaseApi> getMatrixDatabaseImplementation(String clientName) async {
-  var port =
-      IsolateNameServer.lookupPortByName(_getIsolateNameForClient(clientName));
+  var path = await AppConfig.getDriftDatabasePath();
+  path = p.join(path, clientName, "data.db");
+  var dir = p.dirname(path);
 
-  var isolate = DriftIsolate.fromConnectPort(
-      port ?? (await _createIsolate(clientName)).connectPort);
+  if (!await Directory(dir).exists()) {
+    await Directory(dir).create(recursive: true);
+  }
 
-  return MatrixSdkDriftDatabase.init(await isolate.connect(), clientName,
+  final file = File(path);
+
+  var connection = await DatabaseIsolate.connect(file.absolute.path);
+
+  return MatrixSdkDriftDatabase.init(connection, clientName,
       benchmark: benchmarkFunc);
 }
 
@@ -29,41 +29,6 @@ Future<T> benchmarkFunc<T>(String name, Future<T> Function() func,
   return Diagnostics.databaseDiagnostics.timeAsync(name, func);
 }
 
-Future<DriftIsolate> _createIsolate(String clientName) async {
-  final token = RootIsolateToken.instance!;
-  var isolate = await DriftIsolate.spawn(
-    () {
-      BackgroundIsolateBinaryMessenger.ensureInitialized(token);
-
-      return LazyDatabase(() async {
-        var path = await AppConfig.getDriftDatabasePath();
-        path = p.join(path, clientName, "data.db");
-        var dir = p.dirname(path);
-
-        if (!await Directory(dir).exists()) {
-          await Directory(dir).create(recursive: true);
-        }
-
-        final file = File(path);
-        return NativeDatabase(file);
-      });
-    },
-    isolateSpawn: <T>(Function(T message) entryPoint, T message) {
-      return Isolate.spawn(entryPoint, message,
-          debugName: "Client $clientName DB Isolate");
-    },
-  );
-
-  IsolateNameServer.registerPortWithName(
-      isolate.connectPort, _getIsolateNameForClient(clientName));
-
-  return isolate;
-}
-
-String _getIsolateNameForClient(String clientName) {
-  return "chat.commet.commetapp.isolate.client_$clientName";
-}
-
 Future<DatabaseApi?> getLegacyMatrixDatabaseImplementation(
     String clientName) async {
   return null;

commet/lib/main.dart

@@ -18,6 +18,7 @@ import 'package:commet/ui/pages/main/main_page.dart';
 import 'package:commet/utils/android_intent_helper.dart';
 import 'package:commet/utils/custom_uri.dart';
 import 'package:commet/utils/background_tasks/background_task_manager.dart';
+import 'package:commet/utils/database/database_server.dart';
 import 'package:commet/utils/emoji/unicode_emoji.dart';
 import 'package:commet/utils/event_bus.dart';
 import 'package:commet/utils/scaled_app.dart';
@@ -145,6 +146,8 @@ WidgetsBinding ensureBindingInit() {
 Future<void> initNecessary() async {
   sqfliteFfiInit();
   await preferences.init();
+  await initDatabaseServer();
+
   fileCache = FileCache.getFileCacheInstance();
 
   await Future.wait([

commet/lib/utils/database/database_server.dart

@@ -0,0 +1,6 @@
+import 'database_server_stub.dart'
+    if (dart.library.io) 'database_server_io.dart';
+
+Future<void> initDatabaseServer() async {
+  await initDatabaseServerImpl();
+}

commet/lib/utils/database/database_server_io.dart

@@ -0,0 +1,5 @@
+import 'package:commet/utils/database/multiple_database_server.dart';
+
+Future<void>? initDatabaseServerImpl() async {
+  await DatabaseIsolate.start();
+}

commet/lib/utils/database/database_server_stub.dart

@@ -0,0 +1 @@
+Future<void>? initDatabaseServerImpl() => null;

commet/lib/utils/database/multiple_database_server.dart

@@ -0,0 +1,62 @@
+import 'dart:io';
+import 'dart:isolate';
+import 'dart:ui';
+
+import 'package:drift/drift.dart';
+import 'package:drift/isolate.dart';
+import 'package:drift/native.dart';
+
+final class MultiDatabaseServer {
+  final Map<String, DriftIsolate> _activeIsolates = {};
+  final ReceivePort _receiveConnections = ReceivePort();
+
+  MultiDatabaseServer() {
+    _receiveConnections.listen((message) {
+      if (message is (String, SendPort)) {
+        final name = message.$1;
+        final isolate = _activeIsolates.putIfAbsent(
+          name,
+          () {
+            return DriftIsolate.inCurrent(
+                // obviously you can pass a path instead of a name and use that to open the right NativeDatabase
+                () => NativeDatabase(File(name)));
+          },
+        );
+
+        message.$2.send(isolate.connectPort);
+      }
+    });
+  }
+}
+
+class DatabaseIsolate {
+  static final receiveConnectPort = ReceivePort();
+  static SendPort? connectToServer;
+  static const isolateName = "chat.commet.commetapp.database_isolate";
+
+  static Future<void> start() async {
+    connectToServer = IsolateNameServer.lookupPortByName(isolateName);
+    if (connectToServer == null) {
+      Isolate.spawn(
+        (SendPort port) {
+          final server = MultiDatabaseServer();
+          port.send(server._receiveConnections.sendPort);
+        },
+        receiveConnectPort.sendPort,
+        debugName: "Database Isolate",
+      );
+
+      connectToServer = await receiveConnectPort.first as SendPort;
+      IsolateNameServer.registerPortWithName(connectToServer!, isolateName);
+    }
+  }
+
+  static Future<DatabaseConnection> connect(String databaseName) async {
+    final response = ReceivePort();
+    connectToServer!.send((databaseName, response.sendPort));
+
+    final connectPort = await response.first as SendPort;
+    return DriftIsolate.fromConnectPort(connectPort, serialize: false)
+        .connect();
+  }
+}