Asynchronous tasks and parallel executors, supporting all Dart platforms (JS/Web, Flutter, VM/Native) through transparent internal implementations with `dart:isolate` or only `dart:async`, easily bringing concepts similar to Thread Pools to Dart, without having to deal with `Isolate` and port/channel complexity.

Related tags

Templates async_task
Overview

async_task

pub package Null Safety CI GitHub Tag New Commits Last Commits Pull Requests Code size License FOSSA Status

This package brings asynchronous tasks and parallel executors (similar to classic thread pools) for all Dart platforms (JS/Web, Flutter, VM/Native) through transparent internal implementations, based on dart:isolate or only dart:async, without having to deal with the Isolate complexity.

Motivation

Dart parallelism is based on asynchronous, non-blocking and thread-safe code. This creates a language that facilitates the creation of safe concurrency code, but all running in the same thread, using only 1 thread/core of a device.

If you want to use more than 1 thread/core of a device, Dart VM/Native has Isolate, but the paradigm is not easy to use like classical Thread Pools, or like environments that shares all the memory/objects between threads.

This package was created to facilitate the creation and execution of multiple tasks asynchronously in all Dart Platforms, avoiding platform specific codes by the developer.

Usage

import 'dart:async';

import 'package:async_task/async_task.dart';

void main() async {
  // The tasks to execute:
  var tasks = [
    PrimeChecker(8779),
    PrimeChecker(1046527),
    PrimeChecker(3139581), // Not Prime
    PrimeChecker(16769023),
  ];

  // Instantiate the task executor:
  var asyncExecutor = AsyncExecutor(
    sequential: false, // Non-sequential tasks.
    parallelism: 2, // Concurrency with 2 threads.
    taskTypeRegister: _taskTypeRegister, // The top-level function to register the tasks types.
  );

  // Enable logging output:
  asyncExecutor.logger.enabled = true ;

  // Execute all tasks:
  var executions = asyncExecutor.executeAll(tasks);

  // Wait tasks executions:
  await Future.wait(executions);

  for (var task in tasks) {
    var n = task.n; // Number to check for prime.
    var prime = task.result; // Task result: true if is prime.
    print('$n\t-> $prime \t $task');
  }
}

// This top-level function returns the tasks types that will be registered
// for execution. Task instances are returned, but won't be executed and
// will be used only to identify the task type:
List<AsyncTask> _taskTypeRegister() => [PrimeChecker(0)];

// A task that checks if a number is prime:
class PrimeChecker extends AsyncTask<int, bool> {
  // The number to check if is prime.
  final int n;

  PrimeChecker(this.n);

  // Instantiates a `PrimeChecker` task with `parameters`.
  @override
  AsyncTask<int, bool> instantiate(int parameters) {
    return PrimeChecker(parameters);
  }

  // The parameters of this task:
  @override
  int parameters() {
    return n;
  }

  // Runs the task code:
  @override
  FutureOr<bool> run() {
    return isPrime(n);
  }

  // A simple prime check function:
  bool isPrime(int n) {
    if (n < 2) return false;

    var limit = n ~/ 2;
    for (var p = 2; p < limit; ++p) {
      if (n % p == 0) return false;
    }

    return true;
  }
}

Output:

[INFO] Starting AsyncExecutor{ sequential: false, parallelism: 2, executorThread: _AsyncExecutorMultiThread{ totalThreads: 2, queue: 0 } }
[INFO] Starting _AsyncExecutorMultiThread{ totalThreads: 2, queue: 0 }
[INFO] Created _IsolateThread{ id: 2 ; registeredTasksTypes: [PrimeChecker] }
[INFO] Created _IsolateThread{ id: 1 ; registeredTasksTypes: [PrimeChecker] }
8779     -> true 	 PrimeChecker(8779)[finished]{ result: true ; executionTime: 2 ms }
1046527  -> true 	 PrimeChecker(1046527)[finished]{ result: true ; executionTime: 2 ms }
3139581  -> false 	 PrimeChecker(3139581)[finished]{ result: false ; executionTime: 0 ms }
16769023 -> true 	 PrimeChecker(16769023)[finished]{ result: true ; executionTime: 35 ms }

SharedData

The class SharedData facilitates and optimizes data shared between tasks. The main advantage of data encapsulated with SharedData is to avoid multiple messages, with the same data, between threads/isolates, avoiding concurrency performance issues and multiple duplicated objects in memory (a GC bottleneck).

Here's an example of a task using SharedData:

// A task that checks if a number is prime:
class PrimeChecker extends AsyncTask<int, bool> {
  // The number to check if is prime.
  final int n;

  // A list of known primes, shared between tasks.
  final SharedData<List<int>, List<int>> knownPrimes;

  PrimeChecker(this.n, this.knownPrimes);

  // Instantiates a `PrimeChecker` task with `parameters` and `sharedData`.
  @override
  PrimeChecker instantiate(int parameters, [Map<String, SharedData>? sharedData]) {
    return PrimeChecker(
      parameters,
      sharedData!['knownPrimes'] as SharedData<List<int>, List<int>>,
    );
  }

  // The `SharedData` of this task.
  @override
  Map<String, SharedData> sharedData() => {'knownPrimes': knownPrimes};

  // Loads the `SharedData` from `serial` for each key.
  @override
  SharedData<List<int>, List<int>> loadSharedData(String key, dynamic serial) {
    switch (key) {
      case 'knownPrimes':
        return SharedData<List<int>, List<int>>(serial);
      default:
        throw StateError('Unknown key: $key');
    }
  }

  // The parameters of this task:
  @override
  int parameters() {
    return n;
  }

  // Runs the task code:
  @override
  FutureOr<bool> run() {
    return isPrime(n);
  }

  // A simple prime check function:
  bool isPrime(int n) {
    if (n < 2) return false;

    // The pre-computed primes, optimizing this checking algorithm:
    if (knownPrimes.data.contains(n)) {
      return true;
    }
    
    // It's sufficient to search for prime factors in the range [1,sqrt(N)]:
    var limit = (sqrt(n) + 1).toInt();

    for (var p = 2; p < limit; ++p) {
      if (n % p == 0) return false;
    }

    return true;
  }
}

The field knownPrimes above will be shared between tasks. In platforms with support for dart:isolate knownPrimes will be sent through an Isolate port only once, avoiding multiple copies and unnecessary memory allocations.

AsyncTaskChannel

An AsyncTask can have a communication channel that can be used to send/received messages during task execution.

To use a task channel just override channelInstantiator, than use channelResolved() inside the task and await channel() outside it:

class YourTask extends AsyncTask<String, int> {
  // ...
  
  @override
  AsyncTaskChannel? channelInstantiator() => AsyncTaskChannel(); // You can extend `AsyncTaskChannel` class if needed.

  // ...

  @override
  FutureOr<int> run() async {
    // ...
    
    var channel = channelResolved()!; // The channel is always resolved inside `run()`.
    var result = await channel.sendAndWaitResponse<String, String>('some message');

    // ...
  }
}

Outside communication with the task:

// ...

// Execute the task:
asyncExecutor.execute(task);

// ...

// Wait for the channel to be resolved:
var channel = (await task.channel())!;

// Wait for a message:
var msg = await channel.waitMessage();

// process msg...

// Send a response:
channel.send('Some response');

// ...

An AsyncTaskChannel is automatically closed when a task finishes (returns its result).

Source

The official source code is hosted @ GitHub:

Features and bugs

Please file feature requests and bugs at the issue tracker.

Contribution

Any help from the open-source community is always welcome and needed:

  • Found an issue?
    • Please fill a bug report with details.
  • Wish a feature?
    • Open a feature request with use cases.
  • Are you using and liking the project?
    • Promote the project: create an article, do a post or make a donation.
  • Are you a developer?
    • Fix a bug and send a pull request.
    • Implement a new feature, like other training algorithms and activation functions.
    • Improve the Unit Tests.
  • Have you already helped in any way?
    • Many thanks from me, the contributors and everybody that uses this project!

If you donate 1 hour of your time, you can contribute a lot, because others will do the same, just be part and start with your 1 hour.

Author

Graciliano M. Passos: gmpassos@GitHub.

License

Apache License - Version 2.0

FOSSA Status

Comments
  • [Question] Is `SharedData` the same as Isolate Groups in Dart v2.15?

    [Question] Is `SharedData` the same as Isolate Groups in Dart v2.15?

    First of all, thanks for the great package! Your package has helped me a lot in porting a Java codebase that utilized Thread Pools into Dart code.

    In the said codebase, I have used SharedData to share huge data structure (a Map of deeply nested objects) between the isolates. Is it the same as Isolate Groups introduced in Dart 2.15? If it's not, could it theoretically improve the performance of SharedData?

    Thanks!

    question 
    opened by leovinsen 12
  • Want to use the logger instance set up in the main thread

    Want to use the logger instance set up in the main thread

    Hi amazing developer!

    I'm trying to get this library working for @batch-dart and have a question about logging.

    The framework I'm developing currently generates the logger as a singleton instance in the main thread, but this singleton instance will not work once parallel processing starts in this library.

    I think the reason this will not work is because it will be processed in a separate thread, but I would like to somehow use the singleton instance created in this main thread without recreating it.

    From what I've seen, I think I can use the SharedData specification, but do you have any other suggestions?

    Thank you!

    opened by myConsciousness 4
  • how to use with streams

    how to use with streams

    Thank you for the great package.

    I saw your packages from your comment in this issue: https://github.com/dart-lang/sdk/issues/36097#issuecomment-871281712

    I also have a use case for Dart Isolates. I tried to describe it in the same issue after your comment: https://github.com/dart-lang/sdk/issues/36097#issuecomment-871544816

    I was thinking that if I should use this package and listen to Firestore stream in the main thread and compute each response as an async_task or somehow is it possible to use this package in order to listen to Firestore stream in a completely separate isolate and only send custom objects to main thread?

    opened by deadsoul44 3
  • Executing chunks one by one

    Executing chunks one by one

    I have list of chunks which and I want to process each chunk one by one. I want to execute chunk [0, 0, 0, 0] first, then [1, 1, 1, 1] then [2, 2, 2, 2]. But all the tasks in chunk should run parallely at same time. Any way of doing this?

    import 'dart:async';
    import 'package:async_task/async_task.dart';
    
    void main() async {
      //List of chunks
      List<List<int>> chunks = [
        [0, 0, 0, 0], //chunk contains 4 tasks which should run parallely
        [1, 1, 1, 1], //this chunk only gets executed once previous chunk is done
        [2, 2, 2, 2],
        [3, 3, 3, 3],
        [4, 4, 4, 4],
        [5, 5, 5, 5],
        [6, 6, 6, 6],
        [7, 7, 7, 7],
      ];
      for (final chunk in chunks) {
        threadExecutor(chunk);
      }
    }
    
    void threadExecutor(List chunk) async {
      List<TaskExecutor> tasks = [];
    
      for (final task in chunk) {
        tasks.add(TaskExecutor(task));
      }
    
      var asyncExecutor = AsyncExecutor(
        sequential: false,
        parallelism: 4,
        taskTypeRegister: _taskTypeRegister,
      );
    
      asyncExecutor.logger.enabled = false;
    
      var executions = asyncExecutor.executeAll(tasks);
    
      await Future.wait(executions);
    
      for (var task in tasks) {
        var n = task.n;
        var prime = task.result;
        print('$n\t-> $prime \t $task');
      }
    }
    
    List<AsyncTask> _taskTypeRegister() => [TaskExecutor(0)];
    
    class TaskExecutor extends AsyncTask<int, dynamic> {
      final int n;
    
      TaskExecutor(this.n);
    
      @override
      AsyncTask<int, dynamic> instantiate(int parameters,
          [Map<String, SharedData>? sharedData]) {
        return TaskExecutor(parameters);
      }
    
      @override
      int parameters() {
        return n;
      }
    
      @override
      FutureOr<dynamic> run() async {
        return await myTask(n);
      }
    
      Future myTask(int n) async {
        await Future.delayed(Duration(seconds: 1));
        return n;
      }
    }
    

    Output:

    3       -> 3     TaskExecutor(3)[successful]{ result: 3 ; executionTime: 1027 ms }
    3       -> 3     TaskExecutor(3)[successful]{ result: 3 ; executionTime: 1026 ms }
    3       -> 3     TaskExecutor(3)[successful]{ result: 3 ; executionTime: 1026 ms }
    3       -> 3     TaskExecutor(3)[successful]{ result: 3 ; executionTime: 1019 ms }
    1       -> 1     TaskExecutor(1)[successful]{ result: 1 ; executionTime: 1027 ms }
    1       -> 1     TaskExecutor(1)[successful]{ result: 1 ; executionTime: 1025 ms }
    1       -> 1     TaskExecutor(1)[successful]{ result: 1 ; executionTime: 1025 ms }
    1       -> 1     TaskExecutor(1)[successful]{ result: 1 ; executionTime: 1027 ms }
    2       -> 2     TaskExecutor(2)[successful]{ result: 2 ; executionTime: 1027 ms }
    2       -> 2     TaskExecutor(2)[successful]{ result: 2 ; executionTime: 1026 ms }
    2       -> 2     TaskExecutor(2)[successful]{ result: 2 ; executionTime: 1026 ms }
    2       -> 2     TaskExecutor(2)[successful]{ result: 2 ; executionTime: 1026 ms }
    0       -> 0     TaskExecutor(0)[successful]{ result: 0 ; executionTime: 1027 ms }
    0       -> 0     TaskExecutor(0)[successful]{ result: 0 ; executionTime: 1029 ms }
    0       -> 0     TaskExecutor(0)[successful]{ result: 0 ; executionTime: 1027 ms }
    0       -> 0     TaskExecutor(0)[successful]{ result: 0 ; executionTime: 1026 ms }
    7       -> 7     TaskExecutor(7)[successful]{ result: 7 ; executionTime: 1014 ms }
    7       -> 7     TaskExecutor(7)[successful]{ result: 7 ; executionTime: 1012 ms }
    7       -> 7     TaskExecutor(7)[successful]{ result: 7 ; executionTime: 1012 ms }
    7       -> 7     TaskExecutor(7)[successful]{ result: 7 ; executionTime: 1012 ms }
    4       -> 4     TaskExecutor(4)[successful]{ result: 4 ; executionTime: 1014 ms }
    4       -> 4     TaskExecutor(4)[successful]{ result: 4 ; executionTime: 1013 ms }
    4       -> 4     TaskExecutor(4)[successful]{ result: 4 ; executionTime: 1014 ms }
    4       -> 4     TaskExecutor(4)[successful]{ result: 4 ; executionTime: 1014 ms }
    5       -> 5     TaskExecutor(5)[successful]{ result: 5 ; executionTime: 1013 ms }
    5       -> 5     TaskExecutor(5)[successful]{ result: 5 ; executionTime: 1013 ms }
    5       -> 5     TaskExecutor(5)[successful]{ result: 5 ; executionTime: 1012 ms }
    5       -> 5     TaskExecutor(5)[successful]{ result: 5 ; executionTime: 1013 ms }
    6       -> 6     TaskExecutor(6)[successful]{ result: 6 ; executionTime: 1012 ms }
    6       -> 6     TaskExecutor(6)[successful]{ result: 6 ; executionTime: 1013 ms }
    6       -> 6     TaskExecutor(6)[successful]{ result: 6 ; executionTime: 1013 ms }
    6       -> 6     TaskExecutor(6)[successful]{ result: 6 ; executionTime: 1013 ms }
    
    opened by sukhcha-in 2
  • Example using AsyncTask for fetching remote data

    Example using AsyncTask for fetching remote data

    Could you create an example about API fetching? For example, I have a Weather repository class to handle Weather APIs, that depends on a dio instance. How could I use AsyncTask to get weather from a city (API that need dio instance and locationId)?

    opened by dtvtkien 1
  • Add license scan report and status

    Add license scan report and status

    Your FOSSA integration was successful! Attached in this PR is a badge and license report to track scan status in your README.

    Below are docs for integrating FOSSA license checks into your CI:

    opened by fossabot 1
  • v1.0.19

    v1.0.19

    • Update GitHub CI.
    • sdk: '>=2.17.0 <3.0.0'
    • collection: ^1.17.0
    • async_extension: ^1.0.12
    • ffi: ^2.0.1
    • lints: ^2.0.1
    • test: ^1.22.0
    • dependency_validator: ^3.2.2
    • coverage: ^1.6.1
    • vm_service: ^9.4.0
    opened by gmpassos 0
  • Question on multiple api calls

    Question on multiple api calls

    I want to run several API calls in parallel. Each API yields around 300,000 rows and about 32 pages in total. It takes 30 mins currently. I need to get it below 5 mins. Each request takes about 40 seconds individually and bas about 50 mb of data (on average). Any clue on how to do this?

    I've been looking for a decent implementation for some time now. This package will be very useful for backend stuff (especially cron jobs). Thanks devs!

    opened by realrk95 1
  • Feature request: priority queue for sorting tasks

    Feature request: priority queue for sorting tasks

    As title says, it would be nice to have an implementation of the AsyncExecutor that uses a PriorityQueue instead of a simple list to store the tasks.

    It would be also a really good nice-to-have to let the developer change the requests priority during while the AsyncExecutor executes

    opened by smsimone 0
  • feat request: task cancel

    feat request: task cancel

    Thanks for your awesome work! And i wonder is there any way to cancel a submitted task(in queue or is being executed)? I tried but didn't find.

    My scene is to download images in the background and want download task can be cancelled by user :)

    opened by jiangtian616 0
  • Using with Firebase

    Using with Firebase

    Hi! I want to use Firebase in AsyncTask. Does it support this usage? Because I'm having problem with it. Can I add WidgetsFlutterBinding.ensureInitialized() in AsyncTask run method?

    opened by yun-cheng 5
  • Working with generics

    Working with generics

    Hi. I just wordering how this can work with generic tasks. Because the following:

    List<AsyncTask> _taskTypeRegister() => [
      _FuzzySearchTask(_FuzzySearchTaskArgs(tokenSearchers: const [], fullSearcher: Bitap.empty(), identifiers: null, tokens: [], words: [], options: FuzzyOptions()))
    ];
    

    Won't work for

    class _FuzzySearchTask<T extends Object> extends AsyncTask<_FuzzySearchTaskArgs<T>, List<Result<T>>> {
    

    At the moment at looking up a _FuzzySearchTask of type <User> for example, it will fail because _FuzzySearchTask<User> is not registered.

    investigating 
    opened by tomasweigenast 3
  • Crash: null pointer dereference

    Crash: null pointer dereference

    I'm working on an app that uses many threads to perform operations in parallel. Sometimes it crashes when spawning them. This was when debugging the app in a OnePlus 7 Pro, Android 11.

    Doctor summary (to see all details, run flutter doctor -v):
    [√] Flutter (Channel master, 2.6.0-12.0.pre.379, on Microsoft Windows [Version 10.0.18363.1316], locale en-US)
    [!] Android toolchain - develop for Android devices (Android SDK version 30.0.2)
        X cmdline-tools component is missing
          Run `path/to/sdkmanager --install "cmdline-tools;latest"`
          See https://developer.android.com/studio/command-line for more details.
        X Android license status unknown.
          Run `flutter doctor --android-licenses` to accept the SDK licenses.
          See https://flutter.dev/docs/get-started/install/windows#android-setup for more details.
    [√] Chrome - develop for the web
    [√] Visual Studio - develop for Windows (Visual Studio Community 2019 16.7.5)
    [√] Android Studio (version 4.0)
    [√] VS Code (version 1.62.1)
    [√] Connected device (3 available)
    
    ! Doctor found issues in 1 category.
    
    
    Output logs:
    
    I/flutter (11420): [INFO] Starting AsyncExecutor{ sequential: false, parallelism: 1, maximumWorkers: 1, status: AsyncExecutorStatus.idle, platform: AsyncTaskPlatform{platformType: AsyncTaskPlatformType.isolate, maximumParallelism: 8}, executorThread: _AsyncExecutorMultiThread{ totalThreads: 1, queue: 0 } }
    I/flutter (11420): [INFO] Starting _AsyncExecutorMultiThread{ totalThreads: 1, queue: 0 }
    I/flutter (11420): [INFO] Spawning Isolate for _IsolateThread#32
    I/flutter (11420): [INFO] Starting AsyncExecutor{ sequential: false, parallelism: 1, maximumWorkers: 1, status: AsyncExecutorStatus.idle, platform: AsyncTaskPlatform{platformType: AsyncTaskPlatformType.isolate, maximumParallelism: 8}, executorThread: _AsyncExecutorMultiThread{ totalThreads: 1, queue: 0 } }
    I/flutter (11420): [INFO] Starting _AsyncExecutorMultiThread{ totalThreads: 1, queue: 0 }
    I/flutter (11420): [INFO] Spawning Isolate for _IsolateThread#33
    I/flutter (11420): [INFO] Starting AsyncExecutor{ sequential: false, parallelism: 1, maximumWorkers: 1, status: AsyncExecutorStatus.idle, platform: AsyncTaskPlatform{platformType: AsyncTaskPlatformType.isolate, maximumParallelism: 8}, executorThread: _AsyncExecutorMultiThread{ totalThreads: 1, queue: 0 } }
    I/flutter (11420): [INFO] Starting _AsyncExecutorMultiThread{ totalThreads: 1, queue: 0 }
    I/flutter (11420): [INFO] Spawning Isolate for _IsolateThread#34
    I/flutter (11420): [INFO] Starting AsyncExecutor{ sequential: false, parallelism: 1, maximumWorkers: 1, status: AsyncExecutorStatus.idle, platform: AsyncTaskPlatform{platformType: AsyncTaskPlatformType.isolate, maximumParallelism: 8}, executorThread: _AsyncExecutorMultiThread{ totalThreads: 1, queue: 0 } }
    I/flutter (11420): [INFO] Starting _AsyncExecutorMultiThread{ totalThreads: 1, queue: 0 }
    I/flutter (11420): [INFO] Spawning Isolate for _IsolateThread#35
    F/libc    (11420): Fatal signal 11 (SIGSEGV), code 1 (SEGV_MAPERR), fault addr 0x680 in tid 8647 (DartWorker), pid 11420 (minecraft_cloud)
    *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
    Build fingerprint: 'OnePlus/OnePlus7Pro/OnePlus7Pro:11/RKQ1.201022.002/2110211503:user/release-keys'
    Revision: '0'
    ABI: 'arm64'
    Timestamp: 2021-11-16 16:46:24+0200
    pid: 11420, tid: 8647, name: DartWorker  >>> com.example.my_app <<<
    uid: 10613
    signal 11 (SIGSEGV), code 1 (SEGV_MAPERR), fault addr 0x680
    Cause: null pointer dereference
        x0  b4000073a8694578  x1  000000768bac0b14  x2  0000007384f31aa8  x3  0000000000000020
        x4  0000000000000010  x5  0000000000000007  x6  000000768f9c7000  x7  0000000003d8f9c6
        x8  0000000000000000  x9  0000000000000001  x10 0000000000000001  x11 0000000000000030
        x12 0000000000000000  x13 0000000000000050  x14 ffffffffffffffb0  x15 b4000074e8726d30
        x16 00000073281bd738  x17 000000768bac181c  x18 0000007304f74000  x19 b400007478699800
        x20 0000000000000000  x21 0000007327dc5ffc  x22 00000073281604f8  x23 b400007458674670
        x24 b4000074586745f8  x25 b4000074586746a8  x26 00000000004c4b40  x27 0000000000000001
        x28 0000007328298000  x29 00000000000003e8
        lr  0000007327e5020c  sp  0000007384f31ab0  pc  0000007327e50214  pst 0000000080000000
    backtrace:
          #00 pc 000000000194c214  /data/app/~~VaikyToU5GigP-8EMMP0MQ==/com.example.minecraft_cloud-gTxLdfttzVunJTPgAzayxQ==/lib/arm64/libflutter.so (BuildId: 74dcf7ba2ff1623934141fe7f2915facfec83f3c)
          #01 pc 00000000018d7df4  /data/app/~~VaikyToU5GigP-8EMMP0MQ==/com.example.minecraft_cloud-gTxLdfttzVunJTPgAzayxQ==/lib/arm64/libflutter.so (BuildId: 74dcf7ba2ff1623934141fe7f2915facfec83f3c)
          #02 pc 00000000018da788  /data/app/~~VaikyToU5GigP-8EMMP0MQ==/com.example.minecraft_cloud-gTxLdfttzVunJTPgAzayxQ==/lib/arm64/libflutter.so (BuildId: 74dcf7ba2ff1623934141fe7f2915facfec83f3c)
          #03 pc 0000000001a47c34  /data/app/~~VaikyToU5GigP-8EMMP0MQ==/com.example.minecraft_cloud-gTxLdfttzVunJTPgAzayxQ==/lib/arm64/libflutter.so (BuildId: 74dcf7ba2ff1623934141fe7f2915facfec83f3c)
          #04 pc 0000000001a47e98  /data/app/~~VaikyToU5GigP-8EMMP0MQ==/com.example.minecraft_cloud-gTxLdfttzVunJTPgAzayxQ==/lib/arm64/libflutter.so (BuildId: 74dcf7ba2ff1623934141fe7f2915facfec83f3c)
          #05 pc 00000000019d7a7c  /data/app/~~VaikyToU5GigP-8EMMP0MQ==/com.example.minecraft_cloud-gTxLdfttzVunJTPgAzayxQ==/lib/arm64/libflutter.so (BuildId: 74dcf7ba2ff1623934141fe7f2915facfec83f3c)
          #06 pc 00000000000b0048  /apex/com.android.runtime/lib64/bionic/libc.so (__pthread_start(void*)+64) (BuildId: 07fbaeed7b7a19203975f06be6f1d5ef)
          #07 pc 00000000000503c8  /apex/com.android.runtime/lib64/bionic/libc.so (__start_thread+64) (BuildId: 07fbaeed7b7a19203975f06be6f1d5ef)
    Lost connection to device.
    Exited (sigterm)
    invalid 
    opened by dudizimber 3
Owner
null
This a library to simplify isolate thread communication.

This a library to simplify islate thread communication. It abstracts the data transfer between islate and the main thread into a simple channel, and t

吴楚衡 3 Oct 31, 2022
dna, dart native access. A lightweight dart to native super channel plugin

dna, dart native access. A lightweight dart to native super channel plugin, You can use it to invoke any native code directly in contextual and chained dart code.

Assuner 14 Jul 11, 2022
Flutter physics concepts - Physics Concepts by Ayush P Gupta

Physics Concepts by Ayush P Gupta A Flutter project for physics concepts. About Learn Physics Concept in more visual ways. Wave Theory, Ray Optics are

Ayush P Gupta 64 Apr 30, 2022
A sophisticated tool for managing queues of asynchronous tasks, with a stream interface, strong typing and lots of helpful options.

Secretary A sophisticated task manager. Secretary is a tool for keeping your futures in check. It's useful for managing queues of asynchronous tasks,

Alex Baker 5 Dec 21, 2022
Flutter Download Manager is a Cross-Platform file downloader with Parallel and Batch Download support

Flutter Download Manager is a Cross-Platform file downloader with Parallel and Batch Download support. Manage download tasks by url and be notified of status and their progress. Pause, Cancel, Queue and Resume Downloads.

Nabil Mosharraf 11 Dec 17, 2022
A flutter package uses native implementations to resize an image

fast_image_resizer This package uses native implementations to resize an image.

Soeren Schoenbrod 0 Dec 20, 2021
A GraphQL client for Flutter, bringing all the features from a modern GraphQL client to one easy to use package. Built after react apollo

Flutter GraphQL Table of Contents Flutter GraphQL Table of Contents About this project Installation Usage GraphQL Provider [Graphql Link and Headers]

Snowball Digital 45 Nov 9, 2022
A GraphQL client for Flutter, bringing all the features from a modern GraphQL client to one easy to use package.

GraphQL Flutter ?? Bulletin See the v3 -> v4 Migration Guide if you're still on v3. Maintenance status: Low. Follow #762 for updates on the planned ar

Zino & Co. 3.1k Jan 5, 2023
"FlutterMoneyFormatter" is a Flutter extension to formatting various types of currencies according to the characteristics you like, without having to be tied to any localization.

FlutterMoneyFormatter FlutterMoneyFormatter is a Flutter extension to formatting various types of currencies according to the characteristics you like

Fadhly Permata 81 Jan 1, 2023
Find The Latest trending and upcoming movies and tv shows with MovieDB app. The app contains all info about movies and tv shows. find similar movies or shows, Browse all genres, video trailers, backdrops, logos, and posters.

MovieDB App Features. Dynamic Theming Search Functionality Onboarding-Screen Select favourite movie Home Screen Tranding movie Movies different catego

Ansh rathod 80 Dec 12, 2022
An isolated worker for Flutter (Isolate) and Web (Web Worker). Behaves almost the same as the compute function, except it is not a one-off worker.

A singleton isolated worker for all platforms. On most platforms, it uses Flutter's Isolate, except on the web, since Isolate is not available, it use

Iandi Santulus 30 Nov 11, 2022
The repo contains the source code for all the tutorials on the FilledStacks Youtube channel.

Flutter tutorials The repo contains the source code for all the written tutorials by Filledstacks. All Tutorials plus additional snippets and shorter

Dane Mackier 4.5k Dec 31, 2022
100+ Professional UI implementations with Code in Flutter. Available in Android, iOS, Linux and Web

Flutter UI Challenges My effort on replicating various apps UI on flutter. View on Web Building and running the code [ Updated ] Thank you all for you

Damodar Lohani 4k Dec 28, 2022
Intent - A simple Flutter plugin to deal with Android Intents

A simple flutter plugin to deal with Android Intents - your one stop solution for Android Intents, written with ❤️ .

Anjan Roy 92 Nov 4, 2022
Memebaaz is a video/images sharing app, Anyone can share short videos and images through app, the media will go through admin's approval.

MemeBaaz - Memes & Short Videos App Memebaaz is a Video/images Sharing App, Anyone can share short videos and images through app, the media will go th

Rakesh K. 18 Nov 14, 2022
Dart package for Async Data Loading and Caching. Combine local (DB, cache) and network data simply and safely.

Stock is a dart package for loading data from both remote and local sources. It is inspired by the Store Kotlin library.

xmartlabs 59 Dec 24, 2022
A Dart utility package for easy async task cancellation

Dart Cancellation Token. Inspired by CancellationToken in C#. A Dart utility package for easy async task cancellation.

Petrus Nguyễn Thái Học 4 Sep 6, 2022
A simple flutter app that downloads a file from the internet, shows a custom-made download progress dialog and saves the file to device's internal storage

http_downloader A simple flutter app that downloads a file from the internet using the http plugin. It has a custom-designed progress dialog which dis

Akora Ing. Debrah Kwesi Buabeng 4 Apr 6, 2021