feat: implement focussing the main instance (#2)

UNTESTED

Author: mcquenji

README.md

@@ -1,6 +1,6 @@
 # Flutter Single Instance
 
-Provides utilities for handiling single instancing in Flutter.
+A simple way to check if your application is already running.
 
 | Platform | Support |
 | -------- | ------- |
@@ -24,28 +24,48 @@ flutter pub add flutter_single_instance
 
 ### MacOS
 
-Disable sandboxing in `macos/Runner/DebugProfile.entitlements` and `macos/Runner/Release.entitlements` files.
+Disable sandboxing and enable networking in `macos/Runner/DebugProfile.entitlements` and `macos/Runner/Release.entitlements` files.
 
 ```xml
 <key>com.apple.security.app-sandbox</key>
 <false/>
+
+<key>com.apple.security.network.server</key>
+<true/>
+
+<key>com.apple.security.network.client</key>
+<true/>
 ```
 
+- `com.apple.security.app-sandbox`: Set to false to allow access to the filesystem.
+- `com.apple.security.network.server`: Set to true to allow the app to act as a server and listen for incoming focus requests.
+- `com.apple.security.network.client`: Set to true to allow the app to act as a client and send focus requests to the server (i.e. the main instance).
+
 ## Usage
 
 A simple usage example:
 
 ```dart
+import 'dart:io';
+
+import 'package:flutter/material.dart';
 import 'package:flutter_single_instance/flutter_single_instance.dart';
 
-main() async {
+void main() async {
   WidgetsFlutterBinding.ensureInitialized();
+  await windowManager.ensureInitialized();
 
-  if(await FlutterSingleInstance().isFirstInstance()){
-    runApp(MyApp());
-  }else{
+  if (await FlutterSingleInstance().isFirstInstance()) {
+    runApp(const MyApp());
+  } else {
     print("App is already running");
 
+    final err = await FlutterSingleInstance().focus();
+
+    if (err != null) {
+      print("Error focusing running instance: $err");
+    }
+
     exit(0);
   }
 }
@@ -57,4 +77,4 @@ You can safely use this package in web and other unsupported platforms. It will
 
 ## Limitations
 
-Currently this package does not provide a way to bring the existing instance to the front. If you have any ideas on how to achieve this, please open an issue or a pull request.
+- ~~Currently this package does not provide a way to bring the existing instance to the front. If you have any ideas on how to achieve this, please open an issue or a pull request.~~ This limitation has been resolved in version 1.2.0 (unstable).

analysis_options.yaml

@@ -1,4 +1,13 @@
-include: package:flutter_lints/flutter.yaml
-
-# Additional information about this file can be found at
-# https://dart.dev/guides/language/analysis-options
+linter:
+  rules:
+    package_api_docs: true
+    public_member_api_docs: true
+    package_prefixed_library_names: true
+    library_private_types_in_public_api: true
+    package_names: true
+    lines_longer_than_80_chars: false
+    sort_pub_dependencies: true
+    join_return_with_assignment: true
+    prefer_for_elements_to_map_fromIterable: true
+    null_check_on_nullable_type_parameter: true
+    # yet to be released: document_ignores: true

lib/flutter_single_instance.dart

@@ -1,26 +1,43 @@
-/// Provides utilities for handiling single instancing in Flutter.
+/// A simple way to check if your application is already running.
 ///
-/// A simple usage example:
+/// ---
 ///
 /// ```dart
+/// import 'dart:io';
+///
+/// import 'package:flutter/material.dart';
 /// import 'package:flutter_single_instance/flutter_single_instance.dart';
 ///
-/// main() async {
+/// void main() async {
 ///   WidgetsFlutterBinding.ensureInitialized();
+///   await windowManager.ensureInitialized();
 ///
-///   if(await FlutterSingleInstance().isFirstInstance()){
-///     runApp(MyApp());
-///   }else{
+///   if (await FlutterSingleInstance().isFirstInstance()) {
+///     runApp(const MyApp());
+///   } else {
 ///     print("App is already running");
 ///
+///     final err = await FlutterSingleInstance().focus();
+///
+///     if (err != null) {
+///       print("Error focusing running instance: $err");
+///     }
+///
 ///     exit(0);
 ///   }
 /// }
 /// ```
 library flutter_single_instance;
 
+export 'package:window_manager/window_manager.dart' show windowManager;
+
+import 'dart:convert';
 import 'dart:io';
 import 'package:flutter/foundation.dart';
+import 'package:flutter_single_instance/src/focus.dart';
+import 'package:flutter_single_instance/src/generated/focus.pbgrpc.dart';
+import 'package:flutter_single_instance/src/instance.dart';
+import 'package:grpc/grpc.dart';
 import 'package:path_provider/path_provider.dart';
 import 'src/linux.dart';
 import 'src/macos.dart';
@@ -30,24 +47,27 @@ import 'src/unsupported.dart';
 /// Provides utilities for checking if this is the first instance of the app.
 /// Make sure to call `WidgetsFlutterBinding.ensureInitialized()` before using this class.
 abstract class FlutterSingleInstance {
-  static FlutterSingleInstance? _instance;
+  static FlutterSingleInstance? _singelton;
 
+  /// Internal constructor for implementations.
   @protected
-  const FlutterSingleInstance.internal();
+  FlutterSingleInstance.internal();
+
+  Server? _server;
+  Instance? _instance;
 
+  /// Provides utilities for checking if this is the first instance of the app.
+  /// Make sure to call `WidgetsFlutterBinding.ensureInitialized()` before using this class.
   factory FlutterSingleInstance() {
-    _instance ??= kIsWeb || Platform.isAndroid || Platform.isIOS
-        ? const FlutterSingleInstanceUnsopported()
-        : Platform.isMacOS
-            ? const FlutterSingleInstanceMacOS()
-            : Platform.isLinux
-                ? const FlutterSingleInstanceLinux()
-                : Platform.isWindows
-                    ? const FlutterSingleInstanceWindows()
-                    : throw UnsupportedError(
-                        'Platform ${Platform.operatingSystem} is not supported.');
-
-    return _instance!;
+    _singelton ??= Platform.isMacOS
+        ? FlutterSingleInstanceMacOS()
+        : Platform.isLinux
+            ? FlutterSingleInstanceLinux()
+            : Platform.isWindows
+                ? FlutterSingleInstanceWindows()
+                : FlutterSingleInstanceUnsopported();
+
+    return _singelton!;
   }
 
   /// If enabled [FlutterSingleInstance.isFirstInstance] will always return true.
@@ -71,36 +91,42 @@ abstract class FlutterSingleInstance {
     var pidFile = await getPidFile(processName);
     pidFile!;
 
-    if (pidFile.existsSync()) {
-      var pid = int.parse(pidFile.readAsStringSync());
+    if (!pidFile.existsSync()) {
+      // No pid file, so this is the first instance.
+      await activateInstance(processName);
+      return true;
+    }
 
-      var pidName = await getProcessName(pid);
+    final data = await pidFile.readAsString();
 
-      if (processName != pidName) {
-        // Process does not exist, so we can activate this instance.
-        await _activateInstance(processName);
+    _instance = Instance.fromJson(jsonDecode(data));
 
-        return true;
-      } else {
-        // Process exists, so this is not the first instance.
-        return false;
-      }
-    } else {
-      // No pid file, so this is the first instance.
-      await _activateInstance(processName);
+    final pidName = await getProcessName(_instance!.pid);
 
-      return true;
+    if (processName == pidName) {
+      // Process exists, so this is not the first instance.
+      return false;
     }
+
+    // Process does not exist, so we can activate this instance.
+    await activateInstance(processName);
+
+    return true;
   }
 
-  /// Activates the first instance of the app.
-  /// Writes a pid file to the temp directory.
-  Future<void> _activateInstance(String processName) async {
+  /// Activates the first instance of the app and writes a pid file to the temp directory.
+  @protected
+  Future<void> activateInstance(String processName) async {
     var pidFile = await getPidFile(processName);
 
     if (pidFile?.existsSync() == false) await pidFile?.create();
 
-    await pidFile?.writeAsString(pid.toString());
+    final instance = Instance(
+      pid: pid,
+      port: await startRpcServer(),
+    );
+
+    await pidFile?.writeAsString(jsonEncode(instance.toJson()));
   }
 
   /// Returns the pid file.
@@ -110,4 +136,53 @@ abstract class FlutterSingleInstance {
 
     return File('${tmp.path}/$processName.pid');
   }
+
+  /// Starts an RPC server that listens for focus requests.
+  @protected
+  Future<int> startRpcServer() async {
+    _server = Server.create(
+      services: [FocusService()],
+      codecRegistry: CodecRegistry(
+        codecs: const [
+          GzipCodec(),
+          IdentityCodec(),
+        ],
+      ),
+    );
+
+    await _server!.serve(port: 0);
+
+    return _server!.port!;
+  }
+
+  /// Focuses the running instance of the app and
+  /// returns `null` if the operation was successful or an error message if it failed.
+  Future<String?> focus() async {
+    if (_instance == null) return "No instance to focus";
+    if (_server != null) return "This is the first instance";
+
+    try {
+      final channel = ClientChannel(
+        'localhost',
+        port: _instance!.port,
+        options: ChannelOptions(
+          credentials: ChannelCredentials.insecure(),
+          codecRegistry: CodecRegistry(
+            codecs: const [
+              GzipCodec(),
+              IdentityCodec(),
+            ],
+          ),
+        ),
+      );
+
+      final client = FocusServiceClient(channel);
+
+      final response = await client.focus(FocusRequest());
+
+      return response.success ? null : response.error;
+    } catch (e) {
+      return e.toString();
+    }
+  }
 }

lib/src/focus.dart

@@ -0,0 +1,16 @@
+import 'package:flutter_single_instance/src/generated/focus.pbgrpc.dart';
+import 'package:grpc/grpc.dart';
+import 'package:window_manager/window_manager.dart';
+
+class FocusService extends FocusServiceBase {
+  @override
+  Future<FocusResponse> focus(ServiceCall call, FocusRequest request) async {
+    try {
+      await windowManager.focus();
+
+      return FocusResponse(success: true);
+    } catch (e) {
+      return FocusResponse(success: false, error: e.toString());
+    }
+  }
+}