init static method

Future<RpiGpio> init({
  1. bool i2c = true,
  2. bool spi = true,
  3. bool eeprom = true,
  4. bool uart = true,
  5. Completer<GpioException>? onError,
  6. required dynamic isolateEntryPoint(
    1. SendPort sendPort
    ),
  7. SendPort? testSendPort,
})

Instantiate a new GPIO manager. Clients should use initialize_RpiGpio.

Implementation

static Future<RpiGpio> init({
  bool i2c = true,
  bool spi = true,
  bool eeprom = true,
  bool uart = true,
  Completer<GpioException>? onError,
  required Function(SendPort sendPort) isolateEntryPoint,
  SendPort? testSendPort,
}) async {
  if (_instantiatedGpio) throw GpioException('RpiGpio already instantiated');
  _instantiatedGpio = true;

  const timeout = Duration(seconds: 30);
  final rpiGpio =
      RpiGpio._(onError, i2c: i2c, spi: spi, eeprom: eeprom, uart: uart);
  final receivePort = ReceivePort();
  final onErrorPort = ReceivePort();

  final rspHandler = _RpiGpioResponseHandler(rpiGpio);
  var receivePortSubscription = receivePort.listen((data) {
    comm.dispatchRsp(data, rspHandler);
  });
  var onErrorSubscription = onErrorPort.listen(rspHandler.onError);

  await Isolate.spawn(isolateEntryPoint, receivePort.sendPort,
      onError: onErrorPort.sendPort);
  try {
    await rspHandler.initCompleter.future.timeout(timeout);
    if (testSendPort != null) {
      rpiGpio._sendPort.send(comm.testCmd(testSendPort));
    }
  } on TimeoutException {
    await receivePortSubscription.cancel();
    await onErrorSubscription.cancel();
    throw GpioException('init timeout');
  } catch (error) {
    await receivePortSubscription.cancel();
    await onErrorSubscription.cancel();
    rethrow;
  }

  return rpiGpio
    .._receivePortSubscription = receivePortSubscription
    .._onErrorSubscription = onErrorSubscription
    .._rspHandler = rspHandler;
}