submitIsolate<I, T> method

LevitTaskExecution<T> submitIsolate<I, T>(
  1. LevitIsolateTask<I, T> task,
  2. I input, {
  3. String? id,
  4. TaskPriority priority = TaskPriority.normal,
  5. TaskConflictPolicy conflictPolicy = TaskConflictPolicy.reject,
  6. int retries = 0,
  7. Duration? retryDelay,
  8. bool useExponentialBackoff = true,
  9. void onError(
    1. Object error,
    2. StackTrace stackTrace
    )?,
  10. TaskCachePolicy<T>? cachePolicy,
  11. void onStart()?,
  12. void onSuccess(
    1. T result
    )?,
  13. void onProgress(
    1. double progress
    )?,
  14. void onCancel()?,
  15. void onEvent(
    1. LevitTaskEvent event
    )?,
  16. LevitTaskMetadata? metadata,
  17. String? debugName,
})

Submits a message-safe top-level/static task in a new isolate.

Implementation

LevitTaskExecution<T> submitIsolate<I, T>(
  LevitIsolateTask<I, T> task,
  I input, {
  String? id,
  TaskPriority priority = TaskPriority.normal,
  TaskConflictPolicy conflictPolicy = TaskConflictPolicy.reject,
  int retries = 0,
  Duration? retryDelay,
  bool useExponentialBackoff = true,
  void Function(Object, StackTrace)? onError,
  TaskCachePolicy<T>? cachePolicy,
  void Function()? onStart,
  void Function(T result)? onSuccess,
  void Function(double progress)? onProgress,
  void Function()? onCancel,
  void Function(LevitTaskEvent event)? onEvent,
  LevitTaskMetadata? metadata,
  String? debugName,
}) {
  _ensureUsable();
  if (retries < 0) throw RangeError.range(retries, 0, null, 'retries');
  if (retryDelay != null && retryDelay.isNegative) {
    throw ArgumentError.value(retryDelay, 'retryDelay');
  }

  final taskId = id ?? _generateTaskId();
  final taskMetadata = metadata ??
      (debugName == null
          ? LevitTaskMetadata.none
          : LevitTaskMetadata(debugName: debugName));
  late _TaskExecution execution;
  final config = _TaskExecutionConfig(
    task: (context) => _runInTaskIsolate<I, T>(
      task: task,
      input: input,
      context: context,
      cancellation: execution.cancellation,
    ),
    priority: priority,
    retries: retries,
    retryDelay: retryDelay,
    useExponentialBackoff: useExponentialBackoff,
    onError: onError,
    cachePolicy: cachePolicy,
    onStart: onStart,
    onSuccess:
        onSuccess == null ? null : (dynamic value) => onSuccess(value as T),
    onProgress: onProgress,
    onCancel: onCancel,
    onEvent: onEvent,
    metadata: taskMetadata,
    runsInIsolate: true,
  );

  return _submitConfig<T>(
    taskId: taskId,
    config: config,
    conflictPolicy: conflictPolicy,
    captureExecution: (value) => execution = value,
  );
}