Merge pull request #247 from hellcp/background

Fix the communication between the app and the background

lib/domain/apps/requests/app_reorder_request.dart

@@ -5,4 +5,19 @@ class AppReorderRequest {
   final int newPosition;
 
   AppReorderRequest(this.uuid, this.newPosition);
+
+  Map<String, dynamic> toMap() {
+    return {
+      'type': 'AppReorderRequest',
+      'uuid': uuid.toString(),
+      'newPosition': newPosition,
+    };
+  }
+
+  factory AppReorderRequest.fromMap(Map<String, dynamic> map) {
+    return AppReorderRequest(
+      Uuid.parse(map['uuid'] as String),
+      map['newPosition'] as int,
+    );
+  }
 }

lib/domain/apps/requests/force_refresh_request.dart

@@ -2,4 +2,12 @@ class ForceRefreshRequest {
   final bool clear;
 
   ForceRefreshRequest(this.clear);
+
+  Map<String, dynamic> toMap() {
+    return {'type': 'ForceRefreshRequest', 'clear': clear};
+  }
+
+  factory ForceRefreshRequest.fromMap(Map<String, dynamic> map) {
+    return ForceRefreshRequest(map['clear'] as bool);
+  }
 }

lib/infrastructure/backgroundcomm/BackgroundReceiver.dart

@@ -19,12 +19,18 @@ void startReceivingRpcRequests(ReceivingFunction receivingFunction) {
 
   receivingPort.listen((message) {
     Future.microtask(() async {
-      if (message is! RpcRequest) {
-        throw Exception("Message is not RpcRequest: $message");
+      RpcRequest request;
+
+      if (message is Map<String, dynamic>) {
+        try {
+          request = RpcRequest.fromMap(message);
+        } catch (e) {
+          throw Exception("Error creating RpcRequest from Map: $e");
+        }
+      } else {
+        throw Exception("Message is not a Map representing RpcRequest: $message");
       }
 
-      final request = message as RpcRequest;
-
       RpcResult result;
       try {
         final resultObject = await receivingFunction(request.input);
@@ -39,7 +45,7 @@ void startReceivingRpcRequests(ReceivingFunction receivingFunction) {
       );
 
       if (returnPort != null) {
-        returnPort.send(result);
+        returnPort.send(result.toMap());
       }
 
       // If returnPort is null, then receiver died and

lib/infrastructure/backgroundcomm/BackgroundRpc.dart

@@ -39,7 +39,7 @@ class BackgroundRpc {
     final completer = Completer<AsyncValue<Object>>();
     _pendingCompleters[requestId] = completer;
 
-    port.send(request);
+    port.send(request.toMap());
 
     final result = await completer.future;
     return result as AsyncValue<O>;
@@ -53,12 +53,19 @@ class BackgroundRpc {
         returnPort.sendPort, isolatePortNameReturnFromBackground);
 
     returnPort.listen((message) {
-      if (message is! RpcResult) {
+      RpcResult receivedMessage;
+
+      if (message is Map<String, dynamic>) {
+        try {
+          receivedMessage = RpcResult.fromMap(message);
+        } catch (e) {
+          throw Exception("Error creating RpcResult from Map: $e");
+        }
+      } else {
         Log.e("Unknown message: $message");
         return;
       }
 
-      final receivedMessage = message as RpcResult;
       final waitingCompleter = _pendingCompleters[receivedMessage.id];
       if (waitingCompleter == null) {
         return;

lib/infrastructure/backgroundcomm/RpcRequest.dart

@@ -1,9 +1,54 @@
+import 'package:cobble/domain/apps/requests/force_refresh_request.dart';
+import 'package:cobble/domain/apps/requests/app_reorder_request.dart';
+
 class RpcRequest {
   final int requestId;
   final Object input;
 
   RpcRequest(this.requestId, this.input);
 
+  Map<String, dynamic> toMap() {
+    return {
+      'type': 'RpcRequest',
+      'requestId': requestId,
+      'input': _mapInput(),
+    };
+  }
+
+  factory RpcRequest.fromMap(Map<String, dynamic> map) {
+    final String type = map['type'] as String;
+    if (type == 'RpcRequest') {
+      return RpcRequest(
+        map['requestId'] as int,
+        _createInputFromMap(map['input']),
+      );
+    }
+    throw ArgumentError('Invalid type: $type');
+  }
+
+  dynamic _mapInput() {
+    if (input is ForceRefreshRequest) {
+      return {'type': 'ForceRefreshRequest', 'data': (input as ForceRefreshRequest).toMap()};
+    } else if (input is AppReorderRequest) {
+      return {'type': 'AppReorderRequest', 'data': (input as AppReorderRequest).toMap()};
+    }
+    throw ArgumentError('Unsupported input type: ${input.runtimeType}');
+  }
+
+  static Object _createInputFromMap(Map<String, dynamic> map) {
+    final String type = map['type'] as String;
+    final Map<String, dynamic> data = map['data'] as Map<String, dynamic>;
+
+    switch (type) {
+      case 'ForceRefreshRequest':
+        return ForceRefreshRequest.fromMap(data);
+      case 'AppReorderRequest':
+        return AppReorderRequest.fromMap(data);
+      default:
+        throw ArgumentError('Invalid input type: $type');
+    }
+  }
+
   @override
   String toString() {
     return 'RpcRequest{requestId: $requestId, input: $input}';

lib/infrastructure/backgroundcomm/RpcResult.dart

@@ -7,6 +7,26 @@ class RpcResult {
   RpcResult(
       this.id, this.successResult, this.errorResult, this.errorStacktrace);
 
+  Map<String, dynamic> toMap() {
+    return {
+      'id': id,
+      'successResult': successResult,
+      'errorResult': errorResult,
+      'errorStacktrace': errorStacktrace?.toString(),
+    };
+  }
+
+  static RpcResult fromMap(Map<String, dynamic> map) {
+    return RpcResult(
+      map['id'] as int,
+      map['successResult'],
+      map['errorResult'],
+      map['errorStacktrace'] != null
+          ? StackTrace.fromString(map['errorStacktrace'] as String)
+          : null,
+    );
+  }
+
   @override
   String toString() {
     return 'RpcResult{id: $id, '