No way to get receivePort without restarting task handler

[insidewhy]

1. Open the app and start the task handler.
2. Close the app (i.e. hit app switcher and swipe app away).
3. Observe the isolate is still running and handling onEvent.
4. Open the app via the notification button and observe that the related receivePort that was previously stored in memory is now null.
5. Now there is no way to connect a ReceivePort to the isolate that is still running. You can call FlutterForegroundTask.restartService to get a new receive port, but this destroys your task handler which causes you to lose all the state you've accumulated in it.

If the isolate is lost once the app is stopped, then is there any point in still keeping it running? Or should I be constantly writing to shared preferences so that I can resume?

[Dev-hwang]

Currently, the ReceivePort object is created and managed in the main isolate. When the app exits, the ReceivePort object is also destroyed because the main isolate is destroyed. Running the app again starts a new main isolate, so we need to create a new ReceivePort object as well.

At my current level, there seems to be no way. If there is a better way, please let me know.

Best choice in this situation seems to be to use the shared_preferences plugin to constantly save the task state and get the task state when the service is restarted.

[insidewhy]

I've managed to work around this using shared_preferences but it was a lot of work with so many corner cases to test. It also substantially limits what you can do with this library, since all data structures must be serialisable.

I wonder... isolate control ports can be sent to other isolates. So maybe it would be possible to create the receive port in the task handler isolate and then send that port itself as the only message over an initial receive port (internally managed by the library) so that this receive port can be reused?

[insidewhy]

I've just been running some tests, and it's easily possible to send a port over another port, and then use that port from the isolate that receives the port.

So I think this limitation is probably possible to work around and could really improve and simplify this library. IMO it's worth reopening this.

[widavies]

MO it's worth reopening this.

Agreed

[Dev-hwang]

@insidewhy @widavies

You can get the previous ReceivePort without restarting the service.

class ExamplePage extends StatefulWidget {
  const ExamplePage({Key? key}) : super(key: key);

  @override
  State<StatefulWidget> createState() => _ExamplePageState();
}

class _ExamplePageState extends State<ExamplePage> {
  ReceivePort? _receivePort;

  // ...

  Future<bool> _startForegroundTask() async {
    ReceivePort? receivePort;
    if (await FlutterForegroundTask.isRunningService) {
      receivePort = await FlutterForegroundTask.restartService();
    } else {
      receivePort = await FlutterForegroundTask.startService(
        notificationTitle: 'Foreground Service is running',
        notificationText: 'Tap to return to the app',
        callback: startCallback,
      );
    }

    return _registerReceivePort(receivePort);
  }

  bool _registerReceivePort(ReceivePort? receivePort) {
    _closeReceivePort();

    if (receivePort != null) {
      _receivePort = receivePort;
      _receivePort?.listen((message) {
        if (message is DateTime) {
          print('timestamp: ${message.toString()}');
        }
      });

      return true;
    }

    return false;
  }

  void _closeReceivePort() {
    _receivePort?.close();
    _receivePort = null;
  }

  @override
  void initState() {
    super.initState();
    _initForegroundTask();
    WidgetsBinding.instance?.addPostFrameCallback((_) async {
      // You can get the previous ReceivePort without restarting the service.
      if (await FlutterForegroundTask.isRunningService) {
        final newReceivePort = await FlutterForegroundTask.receivePort;
        _registerReceivePort(newReceivePort);
      }
    });
  }

  @override
  void dispose() {
    _closeReceivePort();
    super.dispose();
  }
}

[busslina]

@insidewhy @widavies

You can get the previous ReceivePort without restarting the service.

class ExamplePage extends StatefulWidget {
  const ExamplePage({Key? key}) : super(key: key);

  @override
  State<StatefulWidget> createState() => _ExamplePageState();
}

class _ExamplePageState extends State<ExamplePage> {
  ReceivePort? _receivePort;

  // ...

  Future<bool> _startForegroundTask() async {
    ReceivePort? receivePort;
    if (await FlutterForegroundTask.isRunningService) {
      receivePort = await FlutterForegroundTask.restartService();
    } else {
      receivePort = await FlutterForegroundTask.startService(
        notificationTitle: 'Foreground Service is running',
        notificationText: 'Tap to return to the app',
        callback: startCallback,
      );
    }

    return _registerReceivePort(receivePort);
  }

  bool _registerReceivePort(ReceivePort? receivePort) {
    _closeReceivePort();

    if (receivePort != null) {
      _receivePort = receivePort;
      _receivePort?.listen((message) {
        if (message is DateTime) {
          print('timestamp: ${message.toString()}');
        }
      });

      return true;
    }

    return false;
  }

  void _closeReceivePort() {
    _receivePort?.close();
    _receivePort = null;
  }

  @override
  void initState() {
    super.initState();
    _initForegroundTask();
    WidgetsBinding.instance?.addPostFrameCallback((_) async {
      // You can get the previous ReceivePort without restarting the service.
      if (await FlutterForegroundTask.isRunningService) {
        final newReceivePort = await FlutterForegroundTask.receivePort;
        _registerReceivePort(newReceivePort);
      }
    });
  }

  @override
  void dispose() {
    _closeReceivePort();
    super.dispose();
  }
}

You said no need to restart service, but actually you're restarting it:

receivePort = await FlutterForegroundTask.restartService();

[nuc134r]

I have figured how to obtain RecievePort of already running service. But it's actually more like how to tell the service to use new SendPort from a new RecievePort that we will create.

Once the service is running and app is closed on app start you should call FlutterForegroundTask.init as usual. Then trigger FlutterForegroundTask.receivePort getter. It will generate a new RecievePort and internally register it. You can trigger it by subscribing e.g.:

FlutterForegroundTask.receivePort.listen(_onData)

Now the trick is to have interval set and isOnceEvent set to false in FlutterForegroundTask.init. This way your TaskHandler.onRepeatEvent will be called every 500 ms:

FlutterForegroundTask.init(
  // ...
  foregroundTaskOptions: const ForegroundTaskOptions(
    interval: 500,
    isOnceEvent: false,
    // ...
  ),
  // ...
);

And now look at the signature of TaskHandler.onRepeatEvent:

Future<void> onRepeatEvent(DateTime timestamp, SendPort sendPort) async {

Why would it have a SendPort? We already have it in onStart. Does it change over time? Correct! It will be called every 500 ms and bring you brand new shiny SendPort from your most recent app instance! Now let's save it.

  @override
  Future<void> onRepeatEvent(DateTime timestamp, SendPort sendPort) async {
    if (_sendPort != sendPort) {
      _sendPort = sendPort;
    }
  }

You can even send a ReceivePort's SendPort through it and have a reliable bi-directional communication!

Hope this helps.