switch to moor_ffi w/ sqlcipher

lib/utils/database/cipher_db.dart

@@ -0,0 +1,121 @@
+// file from https://gist.github.com/simolus3/5097bbd80ce59f9b957961fe851fd95a#file-cipher_db-dart
+
+import 'dart:async';
+import 'dart:ffi';
+import 'dart:io';
+import 'dart:math';
+
+import 'package:moor/backends.dart';
+import 'package:moor/moor.dart';
+import 'package:moor_ffi/moor_ffi.dart';
+import 'package:moor_ffi/open_helper.dart';
+
+/// Tells `moor_ffi` to use `sqlcipher` instead of the regular `sqlite3`.
+///
+/// This needs to be called before using `moor`, for instance in the `main`
+/// method.
+void init() {
+  const sharedLibraryName = 'libsqlcipher.so';
+
+  open.overrideFor(OperatingSystem.android, () {
+    try {
+      return DynamicLibrary.open(sharedLibraryName);
+    } catch (_) {
+      // On some (especially old) Android devices, we somehow can't dlopen
+      // libraries shipped with the apk. We need to find the full path of the
+      // library (/data/data/<id>/lib/libsqlite3.so) and open that one.
+      // For details, see https://github.com/simolus3/moor/issues/420
+      final appIdAsBytes = File('/proc/self/cmdline').readAsBytesSync();
+
+      // app id ends with the first \0 character in here.
+      final endOfAppId = max(appIdAsBytes.indexOf(0), 0);
+      final appId = String.fromCharCodes(appIdAsBytes.sublist(0, endOfAppId));
+
+      return DynamicLibrary.open('/data/data/$appId/lib/$sharedLibraryName');
+    }
+  });
+
+  open.overrideFor(OperatingSystem.iOS, () => DynamicLibrary.executable());
+}
+
+class VmDatabaseEncrypted extends DelegatedDatabase {
+  /// Creates a database that will store its result in the [file], creating it
+  /// if it doesn't exist.
+  factory VmDatabaseEncrypted(
+    File file, {
+    String password = '',
+    bool logStatements = false,
+  }) {
+    final vmDatabase = VmDatabase(file, logStatements: logStatements);
+    return VmDatabaseEncrypted._(vmDatabase, password);
+  }
+
+  factory VmDatabaseEncrypted.memory({
+    String password = '',
+    bool logStatements = false,
+  }) {
+    final vmDatabase = VmDatabase.memory(logStatements: logStatements);
+    return VmDatabaseEncrypted._(vmDatabase, password);
+  }
+
+  VmDatabaseEncrypted._(
+    VmDatabase vmDatabase,
+    String password,
+  ) : super(
+          _VmEncryptedDelegate(vmDatabase.delegate, password),
+          logStatements: vmDatabase.logStatements,
+          isSequential: vmDatabase.isSequential,
+        );
+}
+
+class _VmEncryptedDelegate extends DatabaseDelegate {
+  final String password;
+  final DatabaseDelegate delegate;
+
+  _VmEncryptedDelegate(
+    this.delegate,
+    this.password,
+  );
+
+  @override
+  Future<void> open(QueryExecutorUser db) async {
+    await delegate.open(db);
+    final keyLiteral = const StringType().mapToSqlConstant(password);
+    await delegate.runCustom('PRAGMA KEY = $keyLiteral', const []);
+    return Future.value();
+  }
+
+  @override
+  FutureOr<bool> get isOpen => delegate.isOpen;
+
+  @override
+  Future<void> runBatched(BatchedStatements statements) {
+    return delegate.runBatched(statements);
+  }
+
+  @override
+  Future<void> runCustom(String statement, List args) {
+    return delegate.runCustom(statement, args);
+  }
+
+  @override
+  Future<int> runInsert(String statement, List args) {
+    return delegate.runInsert(statement, args);
+  }
+
+  @override
+  Future<QueryResult> runSelect(String statement, List args) {
+    return delegate.runSelect(statement, args);
+  }
+
+  @override
+  Future<int> runUpdate(String statement, List args) {
+    return delegate.runUpdate(statement, args);
+  }
+
+  @override
+  TransactionDelegate get transactionDelegate => delegate.transactionDelegate;
+
+  @override
+  DbVersionDelegate get versionDelegate => delegate.versionDelegate;
+}

lib/utils/database/mobile.dart

@@ -1,14 +1,63 @@
+import 'dart:io';
+import 'dart:isolate';
 import 'package:famedlysdk/famedlysdk.dart';
-import 'package:encrypted_moor/encrypted_moor.dart';
+import 'package:sqflite/sqflite.dart' show getDatabasesPath;
+import 'package:path/path.dart' as p;
 import 'package:flutter/material.dart';
+import 'package:moor/moor.dart';
+import 'package:moor/isolate.dart';
+import 'cipher_db.dart' as cipher;
 
-Database constructDb(
+bool _inited = false;
+
+// see https://moor.simonbinder.eu/docs/advanced-features/isolates/
+void _startBackground(_IsolateStartRequest request) {
+  // this is the entry point from the background isolate! Let's create
+  // the database from the path we received
+
+  if (!_inited) {
+    cipher.init();
+    _inited = true;
+  }
+  final executor = cipher.VmDatabaseEncrypted(File(request.targetPath),
+      password: request.password, logStatements: request.logStatements);
+  // we're using MoorIsolate.inCurrent here as this method already runs on a
+  // background isolate. If we used MoorIsolate.spawn, a third isolate would be
+  // started which is not what we want!
+  final moorIsolate = MoorIsolate.inCurrent(
+    () => DatabaseConnection.fromExecutor(executor),
+  );
+  // inform the starting isolate about this, so that it can call .connect()
+  request.sendMoorIsolate.send(moorIsolate);
+}
+
+// used to bundle the SendPort and the target path, since isolate entry point
+// functions can only take one parameter.
+class _IsolateStartRequest {
+  final SendPort sendMoorIsolate;
+  final String targetPath;
+  final String password;
+  final bool logStatements;
+
+  _IsolateStartRequest(
+      this.sendMoorIsolate, this.targetPath, this.password, this.logStatements);
+}
+
+Future<Database> constructDb(
     {bool logStatements = false,
     String filename = 'database.sqlite',
-    String password = ''}) {
+    String password = ''}) async {
   debugPrint('[Moor] using encrypted moor');
-  return Database(EncryptedExecutor(
-      path: filename, password: password, logStatements: logStatements));
+  final dbFolder = await getDatabasesPath();
+  final targetPath = p.join(dbFolder, filename);
+  final receivePort = ReceivePort();
+  await Isolate.spawn(
+    _startBackground,
+    _IsolateStartRequest(
+        receivePort.sendPort, targetPath, password, logStatements),
+  );
+  final isolate = (await receivePort.first as MoorIsolate);
+  return Database.connect(await isolate.connect());
 }
 
 Future<String> getLocalstorage(String key) async {

lib/utils/database/unsupported.dart

@@ -1,9 +1,9 @@
 import 'package:famedlysdk/famedlysdk.dart';
 
-Database constructDb(
+Future<Database> constructDb(
     {bool logStatements = false,
     String filename = 'database.sqlite',
-    String password = ''}) {
+    String password = ''}) async {
   throw 'Platform not supported';
 }
 

lib/utils/database/web.dart

@@ -3,10 +3,10 @@ import 'package:moor/moor_web.dart';
 import 'package:flutter/material.dart';
 import 'dart:html';
 
-Database constructDb(
+Future<Database> constructDb(
     {bool logStatements = false,
     String filename = 'database.sqlite',
-    String password = ''}) {
+    String password = ''}) async {
   debugPrint('[Moor] Using moor web');
   return Database(WebDatabase.withStorage(
       MoorWebStorage.indexedDbIfSupported(filename),