Flutter: 別の分離からプラットフォームチャネルメソッドを呼び出すことができません

cc @ mravn-トリアージのグーグル

二次分離からプラットフォームメッセージを送信しようとすると、エンジンコードはnullを逆参照し、クラッシュします。 私はまだ正確にどこを特定していません。 私は墓石を手に入れましたが、そのようなものを解釈する方法を学ぶ必要があります。

（不器用な）回避策として、セカンダリ分離はプライマリ分離にメッセージの送信を要求する可能性があります。

@sroddy二次分離株で何を達成しようとしているのか聞いてもいいですか？

さまざまなユースケースがあります。例：

• 膨大な量のデータをダウンロードして解析し（dart：convertメソッドは非同期ではありません）、sqfliteプラグイン（プラットフォームバインディングを使用）を使用してsqliteデータベースに保存します。
• UIに提供する前に、データをプリフェッチして解析します。
• ファイルとの間でデータを暗号化/復号化および読み取り/書き込みします（暗号化は、プラットフォームのセキュリティライブラリを使用するためにメソッドチャネルを介して行われます）。

一般に、依存関係を使用して、最終的にプラットフォーム固有のコードを使用してそれらの処理を実行するかどうかが実際にはわからないいくつかのパブリックメソッドを宣言することがあります（たとえば、フラッターファイアについて考えています）。 それらを使用するimhoは、石で書かれたものではなく、時間とともに変化する可能性のある実装の詳細である必要があります。

データはメソッドチャネルに渡される方法ですでにエンコードされているため、回避策は今のところ問題なく、実装するのは比較的簡単です。このため、分離ポートを介しても簡単に渡されますが、パフォーマンスは最適ではないと思います。 。

ただし、実装中に少し行き詰まりました。メインの分離メソッドをセカンダリの分離メソッドから静的メソッドを呼び出す簡単な方法の例を教えてください。

ありがとう

@sroddy背景情報を提供していただきありがとうございます。

メインアイソレートでの静的メソッドの呼び出しについて：直接サポートされていないため、ポートを使用して実装する必要があります。 このパッケージは、その機能を提供する場合があります（例：ここ）。 でも自分で試したことはありません。

ただし、ここでは、プラグインまたは他のライブラリの実装の一部としてプラットフォームチャネル通信が行われる場合にも機能する、より一般的なソリューションを探す必要があります。

これにはまだフックがありませんが、メインの分離ではなく、セカンダリ分離から使用される既知のチャネル名のセットがあると少しの間想定できる場合は、一般的に使用できるはずです。これらのチャネルに対して自分自身を処理するプラットフォームメッセージを再構成し、バイナリメッセージの必要な転送と2つの分離間の応答を透過的に実装します。 プラグインは違いを知ることはありません。

以下にスケッチしたソリューション。

メインアイソレートにポートM1とR1を設定し、セカンダリアイソレートにM2、R2を設定するとします。 メッセージの場合はM、返信の場合はR。

• セカンダリ分離では、チャネルごとにBinaryMessages.setMockMessageHandlerを使用して、プラットフォームのメッセージをM1に転送します（そのチャネルでBinaryMessage.sendを使用するプラグインに透過的に）。 応答コールバックを保存し、メッセージの応答の受信時に正しいものを呼び出すハンドラーを使用してR2を構成します。 BinaryMessages.handlePlatformMessageに転送するハンドラーを使用してM2を構成します。 そこに応答コールバックを実装して、応答をR1に転送します。
• あなたの主な分離株で対称的に。 プラットフォームのメッセージをBinaryMessages.sendに転送するハンドラーを使用してM1を構成します。 プラットフォームからR2に応答を転送する応答コールバックを設定します。 また、チャネルごとにBinaryMessages.setMessageHandlerを呼び出して、M2に転送するプラットフォームからの着信メッセージのハンドラーを設定します。 応答コールバックを保存し、セカンダリ分離からの応答の受信時に正しいものを呼び出すハンドラーを使用してR1を構成します。

@Hixie次のマイルストーンに移動することをお勧めします。 回避策が存在するようです。 優れたソリューションには、APIの設計作業と反復が必要になります。

同じ問題が発生しました。この問題に関するニュースはありますか？

@ mravn-googleこれについて何か更新はありますか？ 私は同じ問題に遭遇しました（たとえば、プラットフォーム側でRSA 2048キーペアを生成する必要があります。これは、古いデバイスやデータの暗号化/復号化に時間がかかります）。 AndroidとiOSの両方のプラットフォームに実装されるため、プラットフォーム側での作業が2倍になるため、スレッドやサービスの作成は避けたいと思います。 これらのプラットフォーム固有の操作をDartから非同期で実行する簡単な方法はありますか？ 回避策は問題ないようですが、FlutterとDartを初めて使用するため、実装に問題があるようです（Isolateなどのメッセージを転送するハンドラーを構成する方法がわかりません）。申し訳ありません。そのことについて。

同じ問題が発生しました。

Android / iOS側でPDFを生成する必要がありますが、そこから呼び出しを実行すると、compute（...）メソッドがアプリをクラッシュさせます。

私はこの問題を抱えています、そして今私は立ち往生しています。

アプリがフォアグラウンドにない場合でも、共有設定からバックグラウンド分離でaccessTokenを読み取りたい（メイン分離が実行されていない可能性があるため、よくわかりません）。

だから、誰かがバックグラウンド分離から永続化されたデータを読み取るための解決策を教えてもらえますか？
私は今本当に困っています。

/ cc @ bkonyiこれはあなたが取り組んでいることに関連しているようです。

同じ問題が発生しました。 CPUバウンドに基づく当社の製品ベース。 分離ではプラットフォーム方式を使用する必要があります。 この問題を解決する別の方法を教えてください。

@ Thomson-Tsui同様の問題があり、@ bkonyiと彼のFlutterGeofencingサンプルによる作業の蒸留に基づいて、flutter_blueや他のプラグインで使用している分離で何かを動作させることができました。 かなりテストされていませんが、試してみてください。

私は同じ問題を抱えています、それは重要だと思います

誰かがこの問題を解決しましたか？

https://pub.dartlang.org/packages/flutter_isolateを使用しています

バックグラウンドでさまざまな間隔でオーディオを再生する必要があります。 これを行う最も簡単な方法は、オーディオを管理する別のIsolateを使用することですが、この機能がないと、ポートを使用した非常に奇妙な回避策が必要になります。

dartから分離を実行すると、ネイティブライブラリがリンクしないと想定しています。

たとえば、Javaからフラッターコードを実行する場合、このメソッドは次のように呼び出されます。

   private native void nativeRunBundleAndSnapshotFromLibrary (
       long nativePlatformViewId,
       <strong i="7">@NonNull</strong> String [] prioritizedBundlePaths,
       <strong i="8">@Nullable</strong> String entrypointFunctionName,
       <strong i="9">@Nullable</strong> String pathToEntrypointFunction,
       <strong i="10">@NonNull</strong> AssetManager manager
   );

すべての魔法が起こる）

これは、複数のFlutterNativeViewを作成した場合、および各実行で次のことを確認できます。

  public void runFromBundle (FlutterRunArguments args)

次に、いくつかの「ダーツ分離株」を取得します

この問題にも直面しています。 すべてプラットフォームチャネルに依存するバックグラウンド分離（場所、ノイズなど）からデータを収集する必要があります。 @ mravn-google-これに対処できるAPIの更新に関するニュースはありますか？

これは、ツールやメディアアプリでは本当に深刻な問題です。
プラットフォームスレッドは簡単な方法ではありません。

私も同様の問題に直面し、今立ち往生しています。

+1（私のプロジェクトも分離されたプラットフォームチャネルをひどく必要とします）

画像をバックグラウンドでレンダリングする必要があります。 各イメージは数秒かかり、メインスレッドで実行するとUIがブロックされるため、分離して実行する必要があります。 私はdart：ui.PictureRecorderの最初のネイティブ呼び出しで立ち往生しており、（ネイティブ関数を使用する）すべてのグラフィカル呼び出しも機能しないと想定しています。 キャンバスで多くの関数を使用しているので、コールバックポートを操作するのは面倒です。

解決策は高く評価されています。

+1この問題が発生しました

@ mravn-googleがオーフスのGoogleで機能しなくなったようです。 これを調査しているGoogleFlutterチームの他の誰かがいるのだろうか。 IMO、これは、弾力性があり堅牢なFlutterアプリケーションを構築するためにFlutterを本格的に使用するための主要なショーストッパーです。

たぶん@sethladdはステータスを与えることができますか？

+1

これに関する更新はありますか？

+1

自分で解決する方法を知っているが、待つだけのバグに遭遇した日は、私がフラッターエンジニアになるまでの最後の希望です。

新しいフラッター/ダーツユーザーのための回避策のより詳細な説明が必要です。 私は2日前に分離株を使い始め、先週はフラッター/ダーツを使い始めました。深刻な労力を要するタスクにメインスレッドを使用する必要があるようです。そのため、フラッターの学習は悪い解決策になります。 使用可能なマルチスレッドがなければ、Kotlinを学び、アプリを2回ビルドするほうがよいでしょう。 初心者にとってわかりやすいものをすべて集められることを願っています。仕事でそれを使用できるように、雇用主にフラッターを学ぶことを正当化できるようにしたいと思っています。
ここにない場合は、おそらくStackOverflowで、ここに質問を投稿しました： https ：//stackoverflow.com/q/57466952/6047611

+1それがすぐに修正されることを願っています

+1私のプロジェクトには分離したプラットフォームチャネルが必要です。

私はこれと同じ問題に遭遇し、@ mravn-googleによって投稿されたものと同様の回避策を使用してパッケージ（ Isolate Handler ）を作成しました。 ただし、Isolate Handlerを使用すると、メインの分離から他の分離と一緒にチャネルを使用できます。 分離内からの直接MethodChannel呼び出しをサポートしますが、現在EventChannelストリームはサポートされていません。 人々が必要としていることが判明した場合は、サポートを追加することを検討します。

回避策の1つの欠点は、分離ハンドラーにチャネル名を指定する必要があることです。 自分でネイティブコードを書いているので、プロジェクトでは問題ありませんが、それ以外の場合は、使用しているプラ​​グインのソースコードを調べて見つける必要があります。

上記ですでに投稿されているもう1つのオプションは、 FlutterIsolateです。これは、別のアプローチを使用しており、検討する価値があります。

うまくいけば、Flutter開発者はこの問題に対する完全で適切な解決策をすぐに提供するでしょう。

編集：

FlutterのファーストパーティのAndroidAlarm Managerプラグインと同様のアプローチを使用する代わりに、ネイティブ側から分離を開始することで、最終的に問題をよりクリーンに解決しました。

私がしなければならなかったのは、ネイティブコードをプラグインに変換して、ネイティブアプリケーションに登録できるようにすることだけでした。これは、比較的簡単な移行でした。 pub.devのプラグインを使用すると、シームレスに機能するため、さらに簡単になります。

ここで更新を+1しますか？

+1

私がここで気づいている興味深いこと：
いくつかのプラグインは、メソッドチャネル呼び出しがDartからバックグラウンドスレッドにメッセージを渡すことを前提として作成されているようです。 これに関連して、そのbgジオフェンスの例に従い、メインスレッドに戻る方法を考えている非常に混乱した人々がいます...
そのプラグインコードは、短いタスクを実行している場合は「ジャンク」を引き起こしませんが、デフォルトでは、Androidでは「UIスレッド」と呼ばれていたプラットフォームスレッドで実行されます。 これにより、ワークロードが高いときにジェスチャが完全にドロップされる可能性があり、他のすべてのメッセージチャネルもブロックされることを理解しています。
その後、プラグインの作成者のエンジニアリングに翻弄されます。 彼らが重い作業をネイティブコードの別のスレッドに移動した場合にのみ、メソッドチャネルで待機するコードを実行します。 これらのメッセージチャネルは、プラットフォームスレッドで実行する必要があります。
私は良いチンメイガルドがここに関係している理論的根拠を理解していますが、それに同意します：

• ほとんどのプラットフォームAPI呼び出しは高速であり、多くの場合、メインスレッドで行う必要があります。
• ネイティブコードでスレッドを説明する方が理にかなっています
• フレームワークのメソッドオーバーライドで「メインスレッド」に戻る方法を見つけることは、AndroidJavaに慣れている人々にとって明らかに混乱を招きます。
  
  
  
  • 最初のプラットフォームスレッドのみのAPI呼び出しを行うときに、それがどのように増加するかを想像することしかできません。
  
  

結果として得られたアーキテクチャは、プラグイン作成者のデフォルトとして重要なアンチパターンを開いたと思います。 一見すると、firebasemlプラグインでさえその処理にプラットフォームスレッドを使用していると思います。
ですから、重い物を持ち上げる人々に何らかの強い警告が与えられたらいいのにと思います。 おそらく、デフォルトのサンプルアプリでは、メッセージチャネルの呼び出しが返されるまでに約20ミリ秒以上かかる場合に画面上のエラーが発生します。おそらく、もっと多くの人の顔になります。 正直なところ、db呼び出しを行う人々を納得させるものは何でも＆c。 すでにスレッドを取得するために行きます。

大井、フリーランチはありません、それは確かです...

最終的に、JavaとSwiftを使用してネイティブプラットフォームスレッドで重いワークロードを実装することになりました。 回避策は見つかりませんでした。

@AndruByrneこれは確かに非常に興味深い情報であり、私はそれを知りませんでした。 プラグインに関連する問題がすでに1つあります。ユーザーがプラグインをバックグラウンドで重い作業を実行する方法として使用しようとしていて、UIがロックされていました。

警告があるはずであることに同意し、プラグインに警告を追加します。

+1これが必要

残念ながら、Flutterは、非常に基本的でありながら非常に重要なものが不足しているため、プライムタイムの準備ができていません。 すべてのFlutterアプリが単純な非同期/待機で解決できるわけではありません。 重労働の場合、Isolateは不可欠であり、別のIsolateからのプラットフォームチャネルメソッド呼び出しを許可できないプラグインは、それらを無意味で冗長にします。 Xamarinでは、これが1日目からフレームワークに組み込まれていました。確かに、これは今すぐ解決策に賛成票を投じる必要があります。

+1これが必要

+1

別の分離からもプラットフォームチャネルメソッドを呼び出す必要があります！

+1

+1

+1

+1これは持っている必要があります

+1
呼び出す必要のあるネイティブSDKがあります。 BackgroundFlutterMethodChannelのようなものがあるといいでしょう。

+1

+1

誰かが_クラッシュがひどく_実際に何を説明しているのかについて何か情報を持っていますか？ ネイティブライブラリを実装する概念実証に取り組んでおり、メソッドチャネルを介してメッセージを送受信するときに、ウォッチドッグタイムアウト（0x8badf00d）やその他の奇妙なエラーが発生しています。

これは、他のスレッドから呼び出されたいくつかのメソッド[および結果]が原因であると思われますが、正確な問題を特定することはできませんでした。

+1

+1

+1

+1

+1これが必要

+1もこれが必要です！

この問題は少なくともP2として優先されるべきだと思います。
私が考えることができるプラットフォームチャネルの使用は

• プラットフォーム固有のAPIを呼び出すには
• プラットフォーム固有の重いタスクをバックグラウンドで実行し、完了したらレポートする

そして、これは主要なブロッカーです。

flutter_downloaderプラグインは、バックグラウンドの分離コードを処理します。 一見の価値があると思います。

私はこれが次のバージョンで解決されることを望んでいましたが、バグはまだ1.12バージョンに残っています！

クライアント側のコードはチャネルの反対側に多くあり、kotlinで記述されており、アプリは単一のhttp接続ごとにほとんどスタックします

Gooooooooooooooogle？!!!!!!!!!!!!？！？！？！？

このプラグインは役立つかもしれませんflutter_isolate

+1これが必要です...さあ

+1

私にとって最大の問題は、Dartとネイティブプラットフォーム間の通信がメインスレッドで行われるという事実です。UIを遅らせたり、ページデータに面倒なコードを記述したりしない限り、大量のデータを送信することは不可能です。

+1これが必要

ページデータに面倒なコードを書く。

@lukaszciastkoページデータにコードを書くとはどういう意味ですか。 大量のデータを送信するときに遅れているUIを解決する方法はありますか？

@YaredTaddese

ISOLATEの機能の複雑さ、およびUIとISOLATE間の相互通信に応じて、ISOLATEを呼び出す前に、ISOLATEがそのジョブを実行するために必要なデータを構造化することにより、UIコードでこの問題を回避できます。 現在のFlutterアプリで豊富なPDFを生成しています。ユーザーは、生成する複数のPDFを選択できます。

それぞれが1〜10,000ページを生成できます。 私のUIは応答性が高く、各ジョブが完了すると、レポートを表示するTABが作成されます-ジョブがTOASTを介して完了し、UIが停止しない場合、ユーザーは通知を受け取ります-ユーザーは、バックグラウンドでビジーなサービスがあることに気づいていませんリッチPDFを生成します。

私のPDF生成はISOLATEであることに注意してください。 ISOLATE-では、CLOUD FIRESTOREから画像をダウンロードしてPDFに埋め込む必要もあります-これはすべて、シームレスに行われます。

@MsXamですが、別の分離からプラットフォーム固有の関数を呼び出すことができません...これにより、メインの分離でプラットフォーム固有の関数を呼び出すことができます...これによりUIが遅れます

私は同じ問題を抱えています、それは非常に重要だと思います

@YaredTaddese

ISOLATEの機能の複雑さ、およびUIとISOLATE間の相互通信に応じて、ISOLATEを呼び出す前に、ISOLATEがそのジョブを実行するために必要なデータを構造化することにより、UIコードでこの問題を回避できます。 現在のFlutterアプリで豊富なPDFを生成しています。ユーザーは、生成する複数のPDFを選択できます。

それぞれが1〜10,000ページを生成できます。 私のUIは応答性が高く、各ジョブが完了すると、レポートを表示するTABが作成されます-ジョブがTOASTを介して完了し、UIが停止しない場合、ユーザーは通知を受け取ります-ユーザーは、バックグラウンドでビジーなサービスがあることに気づいていませんリッチPDFを生成します。

私のPDF生成はISOLATEであることに注意してください。 ISOLATE-では、CLOUD FIRESTOREから画像をダウンロードしてPDFに埋め込む必要もあります-これはすべて、シームレスに行われます。

プラットフォーム固有のコードを呼び出していますか？

誰かが分離からプラットフォームチャネルを呼び出すための回避策を持っていますか？それはUIスレッドからそうするという考えを打ち負かします。

私は同じことに固執しています。

kotlinコードとgetStream.ioAPIを使用してmethodchannelを呼び出していますが、それは地獄のように遅く、Flutter UIがフリーズし、それにコンピューティングを追加したかったのですが、同じエラーが発生しました。

どうすればこれを修正できますか？

私もこれに出くわしました。 私は新しいアプリのプロトタイプを作成していますが、実際にはこの問題は私にとって目を見張るものであり、Flutter以外の他のソリューションを検討することになり、悲しくなります。

この問題への回答の量が示すように、これは主要な問題であり、Flutterアプリのコンテキストでの分離の主なユースケースをほぼ打ち負かします。

私もこれに出くわしました。 私は新しいアプリのプロトタイプを作成していますが、実際にはこの問題は私にとって目を見張るものであり、Flutter以外の他のソリューションを検討することになり、悲しくなります。

この問題への回答の量が示すように、これは主要な問題であり、Flutterアプリのコンテキストでの分離の主なユースケースをほぼ打ち負かします。

ええ、これは大きな問題です。できるだけ早く修正する必要があります

私は10日間フラッターを学んでいて、今のところそれが大好きですが、しばらくして実験すると、問題が発生し始め、欠点がわかります。この問題は、2018年1月5日から公開されています...

このバグを修正してください。

すぐにサポートしたいと思います。

@ jpsarda 、 @ klaszlo8207息を止めないでください。 そして、はい、今日まで、問題の解決策がありました： https：//pub.dev/packages/isolate_handler。 Flutterのごく最近の変更（わずか数日）により、そのルートをたどることができなくなったため、プログラマーは今日プラグを抜かなければなりませんでした。

ただし、これは実際には並列処理を意味するものではないことを知っておく必要があります。 そのように見え、モバイルアプリでは見た目が重要ですが、プラットフォームコードはとにかくメインスレッドで実行されるため、長いタスクを分離からメインスレッドに委任しても実際には何も達成されませんでした。

非同期関数を使用するときはいつでも、デフォルトでdartがマルチスレッドを処理するようにすると便利です。

@spiderion Asyncは、他の多くのプラットフォームと同様に、マルチスレッド化を意図したものではありませんでした。 私を誤解しないでください、プラットフォームチャネルの制限は大きな問題ではないとは言いません（私のアプリは昨日まで言及したプラグインで動作していたので、今は回避策を探す必要があります）が、async / awaitは、最初の日からマルチスレッド化についてではありませんでした。

@zoechiこの問題に関する更新があるかどうか、または修正する計画があるかどうかを知りたいですか？
ありがとう。

@spiderion彼らはそれを実際に修正することはできません、それは分離が機能する方法から来ています。 背後にUIエンジンがないため、プラットフォームチャネル通信はありません。 ただし、役立つ2つのプラグインがあります。

• https://pub.dev/packages/flutter_isolateは、独自のUIバッキングを作成するため、プラグインと通信できる代替の分離を提供します（技術的には、表示されたり処理されたりするものはありません）。

• https://pub.dev/packages/isolate_handlerは、最近のFlutterの変更により以前の使用方法が不可能になったため、上記のパッケージに依存するように変更しました。 flutter_isolate自体ではなく、このパッケージを使用する利点は、処理機能が追加されることです。複数の分離を開始し、それらを追跡でき、分離とメインの間に独自の通信を設定する必要がありません。スレッド（元の在庫IsolateとFlutterIsolateの両方で手動で行う必要があること）は、抽象化されてすぐに利用できるためです。

私は完璧な成功を収めて2番目を使用します。 実際、私はかなり長い間それを使用していて、Flutterを壊す変更が来たとき、私のアプリも壊れたという理由だけで、プログラマーが新しいソリューションに移行するのを手伝いました。 :-)

したがって、コアからのソリューションを期待するのは合理的ではないと思います。特に、ほとんどのユースケースではプラットフォームチャネル通信が必要ないため、バッキングUIエンジンはすべての分離に追加したいものではありません。 追加の機能が必要な場合は、既存のプラグインを使用してください。

こんにちは@deakjahnはあなたの迅速な答えをありがとう。

あなたが提供したソリューションは非常に役立つように見えます。 しかし、それが私の問題を解決できるかどうかはわかりません。 私は現在、ユーザーがInstagramに似たストーリーを作成するという状況にあります。 その場合、アプリはFirebaseストレージに動画とファイルのリストをアップロードする必要があります。アップロードには非常に長い時間がかかる可能性があり（接続が遅い場合は約15分）、ファイルがアップロードされた後、アプリは作成する必要がありますFirebaseクラウド上のドキュメントであるFirestore。 私が遭遇する問題は、ファイルのアップロード中にユーザーがアプリを強制終了すると、タスク全体が完全に実行されないことです。

それは実際には分離者の責任ではありません、それはあなたがそれをするように言うことをするだけです。 Firebaseは、自分で使用したことはありませんが、私が見る限り、停止したアンロードを再開できます。

getBatteryLevelの例を実行しようとしています。
https://flutter.dev/docs/development/platform-integration/platform-channels?tab=android-channel-java-tab
Androidデバイスで実行しようとするとクラッシュします。 誰か助けてもらえますか？ ログがなく、無限ループで実行され続け、まったく同じコードを使用しているため、エラーを確認する方法すらわかりません。

この問題にP5のラベルを付ける??? 🥵

以前のコメントをチェックしてください。 ほとんどの分離株が必要としないメカニズムが必要であるため、これがフレームワークで変更される可能性は非常に低いと思われます。したがって、そのオーバーヘッドを追加しても意味がありません。 あなたがそれを必要とする場合のために、それを解決するためのパッケージがあります。

ユーザーはメカニズムを気にしません。 それがどれほど難しいかどうか。 彼らはただ結果を必要としています。 これは不可能かもしれません。 しかし、ユーザーがそれを必要とする場合、Flutterはそれを提供する必要があります...

実装には制限があり、この機能を既存の分離に追加したり、この機能を使用して新しいAPIを作成したりするには、かなりの時間がかかる可能性があることを理解しています。 これはP5よりも優先度が高いはずだと思います。

また、私はあなたのコメントをすべて読みました、そしてあなたがあなたが作成したパッケージを宣伝しているように私には感じます。

いいえ、それを作成したのは私ではありませんでしたが、数週間前にその所有権を受け入れました。 このスレッドではそれが秘密にされていたとは思いません。 それに加えて、私はあなたが探しているものを提供することができる2つのパッケージ（1つの投稿で、実際には1回だけ）について言及しました。

あなたがそれを読んだ場合、私が最初にこれらを使用した唯一の理由は、あなたが求めていたものとまったく同じ機能が必要だったということでした。 そして、私のアプリは1年以上、問題なくこれに依存しています。 その上、分離株の内部動作に慣れることは、たまにそれらを使用する開発者よりも（さらに、Flutter Webでそれらの対応物に取り組み始めた）、私が書いたことが真実であると私に思わせます：この機能はそうではありませんフレームワークに組み込まれているのは、フレームワークを含めることに反対する議論がかなりあるためです。 時間がかかるからではなく、まったくありません。 比較的短い時間で済みます。 それがすべての分離にバックエンドの複雑さを追加するという理由だけで、それらのほんの一部だけが実際に必要とし、使用するでしょう。

@deakjahnこれらのヒントに感謝します。isolate_handlerを使用すると、ネイティブ側で通知を受け取るたびに、メソッドを呼び出してデータをダート側に送信するのに役立ちますか？ （私はtwilioネイティブSDKを使用しており、ネイティブ側でプッシュ通知を受信して​​います）

これが、プラットフォームチャネルを介した通信に使用するpatformプラグインがあることを意味する場合は、はい、2つのパッケージのいずれかが役立ちます。 通常のコードで動作する場合、これらのパッケージにより、分離されたコードでも動作するようになります。

@deakjahn迅速な対応ありがとうございます！ 私の問題は、通常のプラットフォームチャネルではそれができなかったことです。よくわかりませんが、twilio SDKは、メインスレッドではなく、別の分離でプッシュ通知のリッスンを処理すると思います。これが私の問題だと思います。 2つのパッケージのいずれかを使用して通知を受け取るたびにメソッドを呼び出した場合に機能するかどうかを知りたいと思いました。どうもありがとうございました。 （これが不可能な場合は、ネイティブアプリへの切り替えを検討しています）

Twilioが何であるかさえ知らないので（OK、ググった:-)）、本当に確信が持てません。 ただし、いずれにせよ、ネイティブコードをインターフェイスする場合は、とにかくプラットフォームチャネルを使用する必要があります。 このTwilioを使用するために誰かが作成した既存のプラグインを使用するか、自分で作成するか（この場合、実質的に同じプラグインを作成し、公開せずにローカルで参照します）、または単に関連するプラグインをコピーします独自のアプリにコードを挿入します（外部依存関係にはなりませんが、それ以外は、とにかく実質的に同じコードになります）。

また、プラットフォームチャネルがある場合は、前の回答が適用されます。通常のFlutterアプリのメインスレッドからプラットフォームチャネルとプラグインを既に使用できる場合は、いずれかを使用して分離から同じものを使用できます。 2つのパッケージ。

したがって、この問題は2018年1月5日以降に存在し、追加の努力を払ってもまだ不可能です。 提供されるソリューションは素晴らしいですが、デスクトップではまだ何も機能していません。 したがって、フラッターがデスクトップでどれだけうまく機能しているかを試し、将来の製品が完全にここで立ち往生する可能性があるかどうかを確認したい人のために。
ほとんどすべてのアプリは分離を必要とします。常にいくつかの巨大な計算があるため、このような重要なApi設計の欠陥に何も起こらない可能性はありますか？

プラグインのシステムアラートウィンドウに、このための方法を追加しました

解決策はここに記載されています通信を分離します。
提供されている例では、システムアラートウィンドウプラグインに固有のトークが提供されていますが、他のプラグインに簡単に複製できます。 そして、それを機能させるために他の豪華なプラグインは必要ありません！

これはまだかなり問題になる可能性があります。 これは、プラグインで何かを行うにはアプリスコープにメッセージを送信する必要があるため、バックグラウンド/フォアグラウンドで実行されている分離からプラグインを直接呼び出す方法がないことを意味します。 したがって、アプリが実行されていない場合、バックグラウンドのプラグインで何もする方法はありません。

したがって、たとえば、アプリを閉じたときにFCMプラグインのbackgroundMessageHandlerで共有設定を使用して何かを実行したい場合は、MissingPluginExceptionがスローされます。

または、システムアラートウィンドウでアプリを開きたくない場合。 アラートウィンドウは別の分離で実行されています。 そのため、アプリのスコープ内でコードを実行する必要があります。 アプリは現在閉じているため、これには問題があります。

そして、これが大きな問題である他の多くのシナリオがおそらくあります。

@ michael-あなたが説明するシナリオは、まさに問題がないはずのシナリオです。 バックグラウンドでコードを実行するプラグインは、通常、独自のプラグインレジストリを使用してまったく新しいFlutterEngineをインスタンス化し、その中で実行される分離は、プラットフォームチャネルを介してそれらのプラグインと直接通信できるようになります。

ちなみに、プラグインを使用するために分離が必要な場合、簡単な方法は、その分離をFlutterEngineでラップするだけで、魔法のようにそれらの機能を継承することを意味します。 これは、AndroidおよびiOSでflutter_isolateパッケージが行うことです（ただし、回避策よりも適切な修正を行う方がよいことに同意します。現在利用可能な回避策には、ボトルネック、オーバーヘッドなどがあり、メンテナンスが不十分であるか、サポートが不足している可能性があります。すべてのプラットフォーム。）

@ryanheiseだからflutter_isolateは私のためにそれをしますか？ ドキュメントから実際にわからない方法。 FCM onBackgroundMessageで機能させるには、何をする必要がありますか？ したがって、onBackgroundMessageHandlerに新しい分離を生成する必要がありますか？ しかし、そこでプラグインを使用することはできないので、flutter_isolateをどのように使用しますか？

問題は、firebase_messagingが長い間更新されておらず、最新のバックグラウンド実行APIよりもはるかに遅れていることです。 プラグインを更新した場合、この問題は発生しなくなります。 もう一度明確にするために、あなたが説明する種類のシナリオは、正しく実装されていればバックグラウンド分離がすでにプラグインにアクセスできるはずなので、問題がないはずのシナリオです。 firebase_messagingプラグインは、最新のAPIに従って実装されていないため、機能しません。 そのプロジェクトでバグレポートを提出できます。

私はこれについて助けを切実に必要としています。 私がこれを行うことができる方法はおそらくありますか？ 私は明日最初の深刻な取引をしました、そして私はそれを理解することができません。

プラグインがロードされていることを確認するためにすべてを行います。 バックグラウンドメッセージを有効にする方法についてREADMEの指示に従ったかどうかはわかりませんが、プラグインのバックグラウンドFlutterNativeViewの初期化にフックするカスタムApplicationクラスを作成する必要があります。 まだ行っていない場合は、どのプラグインも使用できません。 それでも問題が解決しない場合は、プロジェクトを古いv1スタイルのプラグインアーキテクチャにダウングレードしてみてください（v2を必要とする他のプラグインを壊すリスクがあります）。

Application.ktをこのように設定します

import `in`.jvapps.system_alert_window.SystemAlertWindowPlugin
import io.flutter.app.FlutterApplication
import io.flutter.plugin.common.PluginRegistry
import io.flutter.plugin.common.PluginRegistry.PluginRegistrantCallback
import io.flutter.plugins.firebasemessaging.FlutterFirebaseMessagingService

import android.os.Build
import android.app.NotificationManager
import android.app.NotificationChannel

public class Application: FlutterApplication(), PluginRegistrantCallback {

   override fun onCreate() {
     super.onCreate()
     FlutterFirebaseMessagingService.setPluginRegistrant(this)
     createNotificationChannels()
     SystemAlertWindowPlugin.setPluginRegistrant(this)
   }

   override fun registerWith(registry: PluginRegistry) {
     FirebaseCloudMessagingPluginRegistrant.registerWith(registry)
     SystemAlertWindowPlugin.registerWith(registry.registrarFor("in.jvapps.system_alert_window"))
   }

   fun createNotificationChannels() {
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        val name = "groupChannel"
        val descriptionText = "This is the group channel"
        val importance = NotificationManager.IMPORTANCE_HIGH
        val mChannel = NotificationChannel("59054", name, importance)
        mChannel.description = descriptionText
        val notificationManager = getSystemService(NOTIFICATION_SERVICE) as NotificationManager
        notificationManager.createNotificationChannel(mChannel)
    }
  }
}

この問題とは関係がないため、firebase_messagingの問題ページに投稿することをお勧めします。

「SchedulerBinding」用の新しい「spawnIsolate」メソッドを持つPRを作成できます。

次に、この分離でプラットフォームメソッドを呼び出すことが可能になります。

これは、プラットフォームメソッドを呼び出して応答を取得する必要がある場合にのみ役立ちます。

import 'dart:async';
import 'dart:isolate';

import 'package:flutter/scheduler.dart';
import 'package:flutter/widgets.dart';
import 'package:path_provider/path_provider.dart';

Future<void> _test(SendPort sendPort) async {
  final dir = await getTemporaryDirectory();
  sendPort.send(dir);
}

void main() async {
  WidgetsFlutterBinding.ensureInitialized();

  final Completer<Object> completer = Completer<Object>();
  final RawReceivePort receivePort = RawReceivePort(completer.complete);

  final Isolate isolate = await ServicesBinding.instance.spawnIsolate(
    _test,
    receivePort.sendPort,
  );

  print(await completer.future);

  receivePort.close();
  isolate.kill();
}

ログ

Performing hot restart...
Syncing files to device Pixel 4...
Restarted application in 722ms.
I/flutter (11705): Directory: '/data/user/0/com.example.bug/cache'

「SchedulerBinding」用の新しい「spawnIsolate」メソッドを持つPRを作成できます。

次に、この分離でプラットフォームメソッドを呼び出すことが可能になります。

これは、プラットフォームメソッドを呼び出して応答を取得する必要がある場合にのみ役立ちます。

SchedulerBinding.instance.spawnIsolate

これをテストするチャンスはありますか？ それが私のニーズなどに合うなら..

@Nailik
このファイルを置き換えます（バージョン1.17.5の場合は実際）

`` `dart // Copyright 2014 The FlutterAuthors。 全著作権所有。
//このソースコードの使用は、次のようなBSDスタイルのライセンスによって管理されます。
// LICENSEファイルにあります。

import'dart：async ';
import'dart：isolate ';
import'dart：typed_data ';
' dart：ui 'をuiとしてインポートします。

import'package：flutter / Foundation.dart ';

import'asset_bundle.dart ';
import'binary_messenger.dart ';
import'system_channels.dart ';

///プラットフォームメッセージをリッスンし、それらを[defaultBinaryMessenger]に転送します。
///
/// [ServicesBinding]は、公開する[LicenseEntryCollector]も登録します
///アセットのルートに保存されているLICENSEファイルにあるライセンス
///バンドルし、 ext.flutter.evictサービス拡張機能を実装します（を参照）
/// [evict]）。
BindingBase上のmixinServicesBinding {
@オーバーライド
void initInstances（）{
super.initInstances（）;
_instance = this;
_defaultBinaryMessenger = createBinaryMessenger（）;
window.onPlatformMessage = defaultBinaryMessenger.handlePlatformMessage;
initLicenses（）;
SystemChannels.system.setMessageHandler（handleSystemMessage）;
}

///現在の[ServicesBinding]（作成されている場合）。
static ServicesBinding get instance => _instance;
static ServicesBinding _instance;

/// [BinaryMessenger]のデフォルトインスタンス。
///
///これは、アプリケーションからプラットフォームにメッセージを送信するために使用され、
///各チャネルに登録されているハンドラーを追跡するので
///登録されたハンドラーに着信メッセージをディスパッチする場合があります。
BinaryMessenger get defaultBinaryMessenger => _defaultBinaryMessenger;
BinaryMessenger _defaultBinaryMessenger;

///送信に使用できるデフォルトの[BinaryMessenger]インスタンスを作成します
///プラットフォームメッセージ。
@protected
BinaryMessenger createBinaryMessenger（）{
const _DefaultBinaryMessenger ._（）;を返します。
}

///[SystemChannels.system]で受信したメッセージを呼び出すハンドラー
///メッセージチャネル。
///
///他のバインディングがこれをオーバーライドして、着信システムメッセージに応答する場合があります。
@protected
@mustCallSuper
未来handleSystemMessage（Object systemMessage）async {}

///関連するライセンスを[LicenseRegistry]に追加します。
///
///デフォルトでは、[ServicesBinding]の[initLicenses]の実装は追加します
///コンパイル中にflutterツールによって収集されたすべてのライセンス。
@protected
@mustCallSuper
void initLicenses（）{
LicenseRegistry.addLicense（_addLicenses）;
}

ストリーム_addLicenses（）非同期* {
//ここでは（スケジューラバインディングのscheduleTaskではなく）タイマーを使用します
//サービスレイヤーはスケジューラバインディングを使用できないため（スケジューラ
//バインディングはサービスレイヤーを使用してライフサイクルイベントを管理します）。 タイマー
//とにかくscheduleTaskが内部で使用するものです。 唯一の違いは
//これらは、
//実行されている可能性のある他のタスク。 ここで_何か_を使用して中断する
//分離はコピーに時間がかかるため、これを2つの部分に分割することが重要です
//現時点でのデータ、および同じイベントループでデータを受信した場合
//データを次の分離に送信するときの反復、私たちは間違いなく
//フレームを見逃します。 別の解決策は、すべての作業を行うことです
// 1つの分離で発生し、最終的にそこに行く可能性がありますが、最初は
//分離通信をより安くできるかどうかを確認します。
//参照： https ：//github.com/dart-lang/sdk/issues/31959
// https://github.com/dart-lang/sdk/issues/31960
// TODO（ianh）：これらのバグが修正されたら、この複雑さを取り除きます。
ファイナルコンプリーターrawLicenses =コンプリーター（）;
Timer.run（（）async {
rawLicenses.complete（rootBundle.loadString（ 'LICENSE'、cache：false））;
}）;
rawLicenses.futureを待ちます。
ファイナルコンプリーター> parsedLicenses =コンプリーター>（）;
Timer.run（（）async {
parsedLicenses.complete（compute（_parseLicenses、await rawLicenses.future、debugLabel： 'parseLicenses'））;
}）;
parsedLicenses.futureを待ちます。
イールド*ストリーム.fromIterable（parsedLicenses.futureを待つ）;
}

//これは、上記の_addLicensesによって作成された別の分離で実行されます。
静的リスト_parseLicenses（String rawLicenses）{
最終的な文字列_licenseSeparator = '\ n' +（ '-' * 80）+ '\ n';
最終リスト結果=[];
最終リストライセンス= rawLicenses.split（_licenseSeparator）;
for（ライセンスの最終的な文字列ライセンス）{
final int split = license.indexOf（ '\ n \ n'）;
if（split> = 0）{
result.add（LicenseEntryWithLineBreaks（
license.substring（0、split）.split（ '\ n'）、
license.substring（split + 2）、
））;
} それ以外 {
result.add（LicenseEntryWithLineBreaks（const[]、ライセンス））;
}
}
結果を返します。
}

@オーバーライド
void initServiceExtensions（）{
super.initServiceExtensions（）;

assert(() {
  registerStringServiceExtension(
    // ext.flutter.evict value=foo.png will cause foo.png to be evicted from
    // the rootBundle cache and cause the entire image cache to be cleared.
    // This is used by hot reload mode to clear out the cache of resources
    // that have changed.
    name: 'evict',
    getter: () async => '',
    setter: (String value) async {
      evict(value);
    },
  );
  return true;
}());

}

/// ext.flutter.evictサービス拡張に応答して呼び出されます。
///
///これは、ホットリロード中にflutterツールによって使用されるため、すべての画像が
///ディスク上で変更されたものはキャッシュからクリアされます。
@protected
@mustCallSuper
void evict（文字列アセット）{
rootBundle.evict（asset）;
}

未来spawnIsolate（（
FutureOrentryPoint（Tメッセージ）、
Tメッセージ、{
bool paused = false、
bool errorsAreFatal、
SendPort onExit、
SendPort onError、
文字列debugName、
}）{
主張する（
_isMainIsolate、
「複数レベルの分離を作成することはできません」、
）;

final RawReceivePort messageReceiver = RawReceivePort(
  (Object receivedMessage) async {
    if (receivedMessage is SendPort) {
      receivedMessage.send(
        _IsolateStarter<T>(
          ui.PluginUtilities.getCallbackHandle(entryPoint),
          message,
        ),
      );
    } else if (receivedMessage is _Message) {
      final ByteData result = await defaultBinaryMessenger.send(
        receivedMessage.channel,
        receivedMessage.message,
      );
      receivedMessage.sendPort.send(result);
    }
  },
);
RawReceivePort onExitReceiver;
onExitReceiver = RawReceivePort(
  (Object message) {
    onExit?.send(message);

    onExitReceiver.close();
    messageReceiver.close();
  },
);

return Isolate.spawn(
  _startIsolate,
  messageReceiver.sendPort,
  paused: paused,
  errorsAreFatal: true,
  onExit: onExitReceiver.sendPort,
  onError: onError,
  debugName: debugName,
);

}
}

未来_startIsolate（SendPort sendPort）async {
_sendPortToMainIsolate = sendPort;
_IsolateBinding（）;

最終コンプリーター<_IsolateStarter>コンプリーター=
コンプリーター<_IsolateStarter>（）;

最終的なRawReceivePortreceivePort = RawReceivePort（
（オブジェクトisolateStarter）{
assert（isolateStarter is _IsolateStarter）;
completer.complete（isolateStarter as _IsolateStarter）;
}、
）;

sendPort.send（receivePort.sendPort）;

最終的な_IsolateStarterIsolateStarter = await completer.future;

receivePort.close（）;

最終関数関数=
ui.PluginUtilities.getCallbackFromHandle（isolateStarter.callbackHandle）;

await function（isolateStarter.message）;
}

SendPort _sendPortToMainIsolate;

bool get _isMainIsolate => _sendPortToMainIsolate == null;

クラス_IsolateStarter{{
_IsolateStarter（this.callbackHandle、this.message）;

最終的なui.CallbackHandlecallbackHandle;
最後のTメッセージ。
}

クラス_メッセージ{
_メッセージ（
this.channel、
このメッセージ、
this.sendPort、
）;

最終的な文字列チャネル。
最終的なByteDataメッセージ。
最終的なSendPortsendPort;
}

class _IsolateBindingは、ServicesBinding {}を使用してBindingBaseを拡張します

/// [BinaryMessenger]のデフォルトの実装。
///
///このメッセンジャーは、アプリ側からプラットフォーム側にメッセージを送信し、
///プラットフォーム側から適切な場所に着信メッセージをディスパッチします
///ハンドラー。
class _DefaultBinaryMessenger extends BinaryMessenger {
const _DefaultBinaryMessenger ._（）;

//プラットフォームプラグインからの着信メッセージのハンドラー。
//これは静的であるため、このクラスはconstコンストラクターを持つことができます。
静的最終マップ_handlers =
{};

//送信メッセージを傍受して応答するモックハンドラー。
//これは静的であるため、このクラスはconstコンストラクターを持つことができます。
静的最終マップ_mockHandlers =
{};

未来_sendPlatformMessage（String channel、ByteData message）{
ファイナルコンプリーターコンプリーター=コンプリーター（）;

if (_isMainIsolate) {
  // ui.window is accessed directly instead of using ServicesBinding.instance.window
  // because this method might be invoked before any binding is initialized.
  // This issue was reported in #27541. It is not ideal to statically access
  // ui.window because the Window may be dependency injected elsewhere with
  // a different instance. However, static access at this location seems to be
  // the least bad option.
  ui.window.sendPlatformMessage(channel, message, (ByteData reply) {
    try {
      completer.complete(reply);
    } catch (exception, stack) {
      FlutterError.reportError(FlutterErrorDetails(
        exception: exception,
        stack: stack,
        library: 'services library',
        context:
            ErrorDescription('during a platform message response callback'),
      ));
    }
  });
} else {
  RawReceivePort receivePort;
  receivePort = RawReceivePort(
    (Object message) async {
      assert(message is ByteData);
      completer.complete(message as ByteData);
      receivePort.close();
    },
  );
  _sendPortToMainIsolate.send(
    _Message(channel, message, receivePort.sendPort),
  );
}

return completer.future;

}

@オーバーライド
未来handlePlatformMessage（
文字列チャネル、
ByteDataデータ、
ui.PlatformMessageResponseCallbackコールバック、
）非同期{
ByteData応答;
試す {
最終的なMessageHandlerハンドラー= _handlers [channel];
if（handler！= null）{
response = await handler（data）;
} それ以外 {
ui.channelBuffers.push（channel、data、callback）;
コールバック= null;
}
} catch（例外、スタック）{
FlutterError.reportError（FlutterErrorDetails（
例外：例外、
スタック：スタック、
ライブラリ： 'サービスライブラリ'、
コンテキスト：ErrorDescription（ 'プラットフォームメッセージコールバック中'）、
））;
} ついに {
if（callback！= null）{
コールバック（応答）;
}
}
}

@オーバーライド
未来send（String channel、ByteData message）{
最終的なMessageHandlerハンドラー= _mockHandlers [channel];
if（handler！= null）
ハンドラー（メッセージ）を返します。
return _sendPlatformMessage（channel、message）;
}

@オーバーライド
void setMessageHandler（String channel、MessageHandler handler）{
if（handler == null）
_handlers.remove（channel）;
それ以外
_handlers [channel] =ハンドラー;
ui.channelBuffers.drain（channel、（ByteData data、ui.PlatformMessageResponseCallback callback）async {
handlePlatformMessage（channel、data、callback）;を待ちます。
}）;
}

@オーバーライド
void setMockMessageHandler（String channel、MessageHandler handler）{
if（handler == null）
_mockHandlers.remove（channel）;
それ以外
_mockHandlers [channel] =ハンドラー;
}
}
`` `

私はフラッター1.21を持っているので、コンパイルするためにすべてのコードを更新しようとしました。
_IsolateBindingにはBindingBaseメソッドの多くの実装が欠落しているため、1つの問題が残っています...

私はsthのようになります

Error: The non-abstract class '_IsolateBinding' is missing implementations for these members:
 - BindingBase with ServicesBinding.SchedulerBinding.addPersistentFrameCallback

約30回。

最後にコンソールが印刷されます

/C:/flutter/packages/flutter/lib/src/services/binding.dart:341:7: Error: 'BindingBase' doesn't implement 'SchedulerBinding' so it can't be used with 'ServicesBinding'.
 - 'BindingBase' is from 'package:flutter/src/foundation/binding.dart' ('/C:/flutter/packages/flutter/lib/src/foundation/binding.dart').
 - 'SchedulerBinding' is from 'package:flutter/src/scheduler/binding.dart' ('/C:/flutter/packages/flutter/lib/src/scheduler/binding.dart').
 - 'ServicesBinding' is from 'package:flutter/src/services/binding.dart' ('/C:/flutter/packages/flutter/lib/src/services/binding.dart').
class _IsolateBinding extends BindingBase with ServicesBinding {}

_startIsolateでの_IsolateBinding()の呼び出しが何をするのか、100％わかりませんが、よくあるServicesBinding.defaultBinaryMessenger was accessed before the binding was initialized.エラーが発生します。

私はこれを修正しようとしましたが、ミックスインに関する私の知識はまだそれほど良くないと思います。
それを修正する方法はありますか？

// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// <strong i="24">@dart</strong> = 2.8

import 'dart:async';
import 'dart:isolate';
import 'dart:typed_data';
import 'dart:ui' as ui;

import 'package:flutter/foundation.dart';
import 'package:flutter/scheduler.dart';

import 'asset_bundle.dart';
import 'binary_messenger.dart';
import 'restoration.dart';
import 'system_channels.dart';

/// Listens for platform messages and directs them to the [defaultBinaryMessenger].
///
/// The [ServicesBinding] also registers a [LicenseEntryCollector] that exposes
/// the licenses found in the `LICENSE` file stored at the root of the asset
/// bundle, and implements the `ext.flutter.evict` service extension (see
/// [evict]).
mixin ServicesBinding on BindingBase, SchedulerBinding {
  <strong i="25">@override</strong>
  void initInstances() {
    super.initInstances();
    _instance = this;
    _defaultBinaryMessenger = createBinaryMessenger();
    _restorationManager = createRestorationManager();
    window.onPlatformMessage = defaultBinaryMessenger.handlePlatformMessage;
    initLicenses();
    SystemChannels.system.setMessageHandler(handleSystemMessage);
    SystemChannels.lifecycle.setMessageHandler(_handleLifecycleMessage);
    readInitialLifecycleStateFromNativeWindow();
  }

  /// The current [ServicesBinding], if one has been created.
  static ServicesBinding get instance => _instance;
  static ServicesBinding _instance;

  /// The default instance of [BinaryMessenger].
  ///
  /// This is used to send messages from the application to the platform, and
  /// keeps track of which handlers have been registered on each channel so
  /// it may dispatch incoming messages to the registered handler.
  BinaryMessenger get defaultBinaryMessenger => _defaultBinaryMessenger;
  BinaryMessenger _defaultBinaryMessenger;

  /// Creates a default [BinaryMessenger] instance that can be used for sending
  /// platform messages.
  <strong i="26">@protected</strong>
  BinaryMessenger createBinaryMessenger() {
    return const _DefaultBinaryMessenger._();
  }

  /// Called when the operating system notifies the application of a memory
  /// pressure situation.
  ///
  /// This method exposes the `memoryPressure` notification from
  /// [SystemChannels.system].
  <strong i="27">@protected</strong>
  <strong i="28">@mustCallSuper</strong>
  void handleMemoryPressure() { }

  /// Handler called for messages received on the [SystemChannels.system]
  /// message channel.
  ///
  /// Other bindings may override this to respond to incoming system messages.
  <strong i="29">@protected</strong>
  <strong i="30">@mustCallSuper</strong>
  Future<void> handleSystemMessage(Object systemMessage) async {
    final Map<String, dynamic> message = systemMessage as Map<String, dynamic>;
    final String type = message['type'] as String;
    switch (type) {
      case 'memoryPressure':
        handleMemoryPressure();
        break;
    }
    return;
  }

  /// Adds relevant licenses to the [LicenseRegistry].
  ///
  /// By default, the [ServicesBinding]'s implementation of [initLicenses] adds
  /// all the licenses collected by the `flutter` tool during compilation.
  <strong i="31">@protected</strong>
  <strong i="32">@mustCallSuper</strong>
  void initLicenses() {
    LicenseRegistry.addLicense(_addLicenses);
  }

  Stream<LicenseEntry> _addLicenses() async* {
    // We use timers here (rather than scheduleTask from the scheduler binding)
    // because the services layer can't use the scheduler binding (the scheduler
    // binding uses the services layer to manage its lifecycle events). Timers
    // are what scheduleTask uses under the hood anyway. The only difference is
    // that these will just run next, instead of being prioritized relative to
    // the other tasks that might be running. Using _something_ here to break
    // this into two parts is important because isolates take a while to copy
    // data at the moment, and if we receive the data in the same event loop
    // iteration as we send the data to the next isolate, we are definitely
    // going to miss frames. Another solution would be to have the work all
    // happen in one isolate, and we may go there eventually, but first we are
    // going to see if isolate communication can be made cheaper.
    // See: https://github.com/dart-lang/sdk/issues/31959
    //      https://github.com/dart-lang/sdk/issues/31960
    // TODO(ianh): Remove this complexity once these bugs are fixed.
    final Completer<String> rawLicenses = Completer<String>();
    scheduleTask(() async {
      rawLicenses.complete(await rootBundle.loadString('NOTICES', cache: false));
    }, Priority.animation);
    await rawLicenses.future;
    final Completer<List<LicenseEntry>> parsedLicenses = Completer<List<LicenseEntry>>();
    scheduleTask(() async {
      parsedLicenses.complete(compute(_parseLicenses, await rawLicenses.future, debugLabel: 'parseLicenses'));
    }, Priority.animation);
    await parsedLicenses.future;
    yield* Stream<LicenseEntry>.fromIterable(await parsedLicenses.future);
  }

  // This is run in another isolate created by _addLicenses above.
  static List<LicenseEntry> _parseLicenses(String rawLicenses) {
    final String _licenseSeparator = '\n' + ('-' * 80) + '\n';
    final List<LicenseEntry> result = <LicenseEntry>[];
    final List<String> licenses = rawLicenses.split(_licenseSeparator);
    for (final String license in licenses) {
      final int split = license.indexOf('\n\n');
      if (split >= 0) {
        result.add(LicenseEntryWithLineBreaks(
          license.substring(0, split).split('\n'),
          license.substring(split + 2),
        ));
      } else {
        result.add(LicenseEntryWithLineBreaks(const <String>[], license));
      }
    }
    return result;
  }

  <strong i="33">@override</strong>
  void initServiceExtensions() {
    super.initServiceExtensions();

    assert(() {
      registerStringServiceExtension(
        // ext.flutter.evict value=foo.png will cause foo.png to be evicted from
        // the rootBundle cache and cause the entire image cache to be cleared.
        // This is used by hot reload mode to clear out the cache of resources
        // that have changed.
        name: 'evict',
        getter: () async => '',
        setter: (String value) async {
          evict(value);
        },
      );
      return true;
    }());
  }

  /// Called in response to the `ext.flutter.evict` service extension.
  ///
  /// This is used by the `flutter` tool during hot reload so that any images
  /// that have changed on disk get cleared from caches.
  <strong i="34">@protected</strong>
  <strong i="35">@mustCallSuper</strong>
  void evict(String asset) {
    rootBundle.evict(asset);
  }

  Future<Isolate> spawnIsolate<T>(
      FutureOr<void> entryPoint(T message),
      T message, {
        bool paused = false,
        bool errorsAreFatal,
        SendPort onExit,
        SendPort onError,
        String debugName,
      }) {
    assert(
    _isMainIsolate,
    'Can\'t make multiple levels of isolates',
    );

    final RawReceivePort messageReceiver = RawReceivePort(
          (Object receivedMessage) async {
        if (receivedMessage is SendPort) {
          receivedMessage.send(
            _IsolateStarter<T>(
              ui.PluginUtilities.getCallbackHandle(entryPoint),
              message,
            ),
          );
        } else if (receivedMessage is _Message) {
          final ByteData result = await defaultBinaryMessenger.send(
            receivedMessage.channel,
            receivedMessage.message,
          );
          receivedMessage.sendPort.send(result);
        }
      },
    );
    RawReceivePort onExitReceiver;
    onExitReceiver = RawReceivePort(
          (Object message) {
        onExit?.send(message);

        onExitReceiver.close();
        messageReceiver.close();
      },
    );

    return Isolate.spawn(
      _startIsolate,
      messageReceiver.sendPort,
      paused: paused,
      errorsAreFatal: true,
      onExit: onExitReceiver.sendPort,
      onError: onError,
      debugName: debugName,
    );
  }



  // App life cycle

  /// Initializes the [lifecycleState] with the [Window.initialLifecycleState]
  /// from the window.
  ///
  /// Once the [lifecycleState] is populated through any means (including this
  /// method), this method will do nothing. This is because the
  /// [Window.initialLifecycleState] may already be stale and it no longer makes
  /// sense to use the initial state at dart vm startup as the current state
  /// anymore.
  ///
  /// The latest state should be obtained by subscribing to
  /// [WidgetsBindingObserver.didChangeAppLifecycleState].
  <strong i="36">@protected</strong>
  void readInitialLifecycleStateFromNativeWindow() {
    if (lifecycleState != null) {
      return;
    }
    final AppLifecycleState state = _parseAppLifecycleMessage(window.initialLifecycleState);
    if (state != null) {
      handleAppLifecycleStateChanged(state);
    }
  }

  Future<String> _handleLifecycleMessage(String message) async {
    handleAppLifecycleStateChanged(_parseAppLifecycleMessage(message));
    return null;
  }

  static AppLifecycleState _parseAppLifecycleMessage(String message) {
    switch (message) {
      case 'AppLifecycleState.paused':
        return AppLifecycleState.paused;
      case 'AppLifecycleState.resumed':
        return AppLifecycleState.resumed;
      case 'AppLifecycleState.inactive':
        return AppLifecycleState.inactive;
      case 'AppLifecycleState.detached':
        return AppLifecycleState.detached;
    }
    return null;
  }

  /// The [RestorationManager] synchronizes the restoration data between
  /// engine and framework.
  ///
  /// See the docs for [RestorationManager] for a discussion of restoration
  /// state and how it is organized in Flutter.
  ///
  /// To use a different [RestorationManager] subclasses can override
  /// [createRestorationManager], which is called to create the instance
  /// returned by this getter.
  RestorationManager get restorationManager => _restorationManager;
  RestorationManager _restorationManager;

  /// Creates the [RestorationManager] instance available via
  /// [restorationManager].
  ///
  /// Can be overriden in subclasses to create a different [RestorationManager].
  <strong i="37">@protected</strong>
  RestorationManager createRestorationManager() {
    return RestorationManager();
  }
}

Future<void> _startIsolate<T>(SendPort sendPort) async {
  _sendPortToMainIsolate = sendPort;
  _IsolateBinding();

  final Completer<_IsolateStarter<T>> completer =
  Completer<_IsolateStarter<T>>();

  final RawReceivePort receivePort = RawReceivePort(
        (Object isolateStarter) {
      assert(isolateStarter is _IsolateStarter<T>);
      completer.complete(isolateStarter as _IsolateStarter<T>);
    },
  );

  sendPort.send(receivePort.sendPort);

  final _IsolateStarter<T> isolateStarter = await completer.future;

  receivePort.close();

  final Function function =
  ui.PluginUtilities.getCallbackFromHandle(isolateStarter.callbackHandle);

  await function(isolateStarter.message);
}

SendPort _sendPortToMainIsolate;

bool get _isMainIsolate => _sendPortToMainIsolate == null;

class _IsolateStarter<T> {
  _IsolateStarter(this.callbackHandle, this.message);

  final ui.CallbackHandle callbackHandle;
  final T message;
}

class _Message {
  _Message(
      this.channel,
      this.message,
      this.sendPort,
      );

  final String channel;
  final ByteData message;
  final SendPort sendPort;
}

//TODO not working
class _IsolateBinding extends BindingBase with ServicesBinding {}

/// The default implementation of [BinaryMessenger].
///
/// This messenger sends messages from the app-side to the platform-side and
/// dispatches incoming messages from the platform-side to the appropriate
/// handler.
class _DefaultBinaryMessenger extends BinaryMessenger {
  const _DefaultBinaryMessenger._();

  // Handlers for incoming messages from platform plugins.
  // This is static so that this class can have a const constructor.
  static final Map<String, MessageHandler> _handlers =
  <String, MessageHandler>{};

  // Mock handlers that intercept and respond to outgoing messages.
  // This is static so that this class can have a const constructor.
  static final Map<String, MessageHandler> _mockHandlers =
  <String, MessageHandler>{};

  Future<ByteData> _sendPlatformMessage(String channel, ByteData message) {
    final Completer<ByteData> completer = Completer<ByteData>();

    if (_isMainIsolate) {
      // ui.window is accessed directly instead of using ServicesBinding.instance.window
      // because this method might be invoked before any binding is initialized.
      // This issue was reported in #27541. It is not ideal to statically access
      // ui.window because the Window may be dependency injected elsewhere with
      // a different instance. However, static access at this location seems to be
      // the least bad option.
      ui.window.sendPlatformMessage(channel, message, (ByteData reply) {
        try {
          completer.complete(reply);
        } catch (exception, stack) {
          FlutterError.reportError(FlutterErrorDetails(
            exception: exception,
            stack: stack,
            library: 'services library',
            context:
            ErrorDescription('during a platform message response callback'),
          ));
        }
      });
    } else {
      RawReceivePort receivePort;
      receivePort = RawReceivePort(
            (Object message) async {
          assert(message is ByteData);
          completer.complete(message as ByteData);
          receivePort.close();
        },
      );
      _sendPortToMainIsolate.send(
        _Message(channel, message, receivePort.sendPort),
      );
    }

    return completer.future;
  }

  <strong i="38">@override</strong>
  Future<void> handlePlatformMessage(
      String channel,
      ByteData data,
      ui.PlatformMessageResponseCallback callback,
      ) async {
    ByteData response;
    try {
      final MessageHandler handler = _handlers[channel];
      if (handler != null) {
        response = await handler(data);
      } else {
        ui.channelBuffers.push(channel, data, callback);
        callback = null;
      }
    } catch (exception, stack) {
      FlutterError.reportError(FlutterErrorDetails(
        exception: exception,
        stack: stack,
        library: 'services library',
        context: ErrorDescription('during a platform message callback'),
      ));
    } finally {
      if (callback != null) {
        callback(response);
      }
    }
  }

  <strong i="39">@override</strong>
  Future<ByteData> send(String channel, ByteData message) {
    final MessageHandler handler = _mockHandlers[channel];
    if (handler != null)
      return handler(message);
    return _sendPlatformMessage(channel, message);
  }

  <strong i="40">@override</strong>
  void setMessageHandler(String channel, MessageHandler handler) {
    if (handler == null)
      _handlers.remove(channel);
    else
      _handlers[channel] = handler;
    ui.channelBuffers.drain(channel, (ByteData data, ui.PlatformMessageResponseCallback callback) async {
      await handlePlatformMessage(channel, data, callback);
    });
  }

  <strong i="41">@override</strong>
  void setMockMessageHandler(String channel, MessageHandler handler) {
    if (handler == null)
      _mockHandlers.remove(channel);
    else
      _mockHandlers[channel] = handler;
  }

  <strong i="42">@override</strong>
  bool checkMessageHandler(String channel, MessageHandler handler) => _handlers[channel] == handler;

  <strong i="43">@override</strong>
  bool checkMockMessageHandler(String channel, MessageHandler handler) => _mockHandlers[channel] == handler;
}

@Nailik
現時点では、フラッターを更新してあなたを助けることはできません

フラッターチームによって実装された他のフラッターツール（たとえばdevtools）がこのブロッカーにヒットしないのはなぜだろうと思います。
彼らは彼らによってブロックされた場合にのみバグを修正しているようです。

これは重大な新機能ではなく、フレームワークブロッカーです。
したがって、このhttps://github.com/flutter/flutter/issues/18761#issuecomment -639248761によると、P3である必要があります。

フラッターチームによって実装された他のフラッターツール（たとえばdevtools）がこのブロッカーにヒットしないのはなぜだろうと思います。
彼らは彼らによってブロックされた場合にのみバグを修正しているようです。

正直なところ、この問題が実際のアプリに与える影響は過大評価されていると思います。 物事が簡単になるので、私はこの問題を見ているだけですが、「回避策」があります。 また、本番環境の多くのアプリやプラグインはバックグラウンド機能を使用しています。

また、+ 1の一部が、問題の内容を完全に理解していないかどうかもわかりません。 （https://github.com/flutter/flutter/issues/13937#issuecomment-635683123のように）。 Imoは、バックグラウンド分離とヘッドレスランタイム（およびそれを管理する方法）の公式ドキュメントがまだ少し不足しており、Firebaseメッセージングのものは悪夢ですが、これはフレームワーク、エンジンとは関係ありません🤷‍♂️

たぶん、フラッターチームをバッシングするのをやめて、驚くべき進歩があり、これは回避できないものではありません...そしてPRがある場合は、フラッターチームにそれを提出して検討してみませんか🤔

分離に対してこの動作を実装することには問題があります。

例：

メインアイソレートとエンジンがあります。
分離が何かを必要とする場合、それはエンジンに尋ねます。
エンジンが何かを必要とする場合、それは分離に尋ねます。

今、私たちの状況は次のとおりです。
2つの分離株と1つのエンジンがあります。
分離が何かを必要とする場合、それはエンジンに尋ねます。
エンジンが何かを必要とする場合、それは何をすべきですか？
両方に聞いてみませんか？ では、誰が答えるのか？
または、1つの隔離だけを尋ねますか？ では、どれですか？

@hpoulここにいる多くの人々はandroid / iosプログラミングの初心者であり、彼らはアプリ開発のための最初のフレームワークをフラッターにすることを選択したので、私は同意しないことに同意する必要があります。

したがって、誰かがこれを認識し、フレームワークによってブロックされて複雑な「回避策」を実行するように強制されるこの種の問題の例を使用して、公式の回避策を修正または提案することが重要です。ここのコメントやstackoverflowや他のブログのどこにも十分に説明された回避策がないため、どこから始めればよいですか。 これを正しく実装しているかもしれないし、していないかもしれないいくつかのパッケージを指しているものだけがあります。

androidとiosの両方で、サービスやバックグラウンドタスクキューなどを操作した経験が豊富で、これを簡単に回避できる人は、フラッターの対象となる人口統計ではありません。

そして、そのようなトピックのコメントから外れると、他のすべての問題に誤った+1があると確信しています。これは、問題の優先順位をあまり変更せず、この問題は依然としてトップにあります。

こんにちは@phanirithvij

flutter_isolateは上記でリンクされており、2019年2月から存在しています。これも複雑ではありません。 簡単そうなREADMEをコピーします。

FlutterIsolateを使用すると、Flutterプラグインを使用できるFlutterでIsolateを作成できます。 プラットフォームチャネルが分離内で機能できるようにするために必要なプラットフォーム固有のビット（Androidの場合はFlutterBackgroundView、iOSの場合はFlutterEngine）を作成します。

| | Android | iOS | 説明|
| ：--------------- | ：----------------：| ：------------------：| ：-------------------------------- |
| FlutterIsolate.spawn（entryPoint、message）| ：white_check_mark：| ：white_check_mark：| 新しいFlutterIsolateを生成します|
| flutterIsolate.pause（）| ：white_check_mark：| ：white_check_mark：| 実行中の分離を一時停止します|
| flutterIsolate.resume（）| ：white_check_mark：| ：white_check_mark：| 一時停止したisoalteを再開しました|
| flutterIsolate.kill（）| ：white_check_mark：| ：white_check_mark：| 分離株を殺す|

これらのメソッドは「元の」 Isolateクラスのメソッドと同じ名前であるため、簡単に言えます。公式ドキュメントから分離を使用する方法をすでに知っている場合は、使用方法を理解するのは難しいことではありません。これは、少なくとも上記のメソッドでは、ドロップインの代替として使用されます。

（注：私も、以前のコメントですでに述べた理由でこの問題を正式に修正したいと思います。その一部をあなたと共有しますが、この回避策を「複雑」とは呼びません。）

@nikitadolのコメントに応えて、flutter_isolateは分離ごとに個別のエンジンを作成するため、同じ問題が発生することはありません。 もちろん、分離ごとに新しいエンジンを作成する必要があるのは理想的ではありません。これが、Flutterチームがより良い仕事をすることができると確信している理由の1つです。 同様に、すべてのプラグインメソッド呼び出しをメインの分離にパイプする代替ソリューションは、そもそも分離の目標に反するボトルネックを作成するため、Flutterチームもそれをより適切に実行できると確信しています。

Flutterチームが最初に対処する優先度の高い問題があるかもしれないと言った人たちに同意しますが、プラグインアーキテクチャで以前に見たものに基づいて、これを修正するにはアーキテクチャの大幅な変更やその他のいくつかの未解決の問題が必要になる可能性がありますまた、アーキテクチャを大幅に変更する必要があり、これらのさまざまな要件をすべて検討することで、この特定の問題に対処できるようになるまでに時間がかかる可能性があります。

@ryanheise

flutter_isolateは、分離ごとに個別のエンジンを作成します

だから、Flutterチームもそれをも​​っとうまくやれると確信しています。

Flutterチームはこれを行うことができるとあなたは言いますが、どうやって？
上記の質問は引き続き有効です。
解決策が新しいエンジンを作成することである場合は、プラグインを使用するだけです。

（注：flutter_isolateは私のプラグインではありませんが、この機能も必要だったので、プロジェクトに貢献することにしました。）

私が「より良い仕事」とは、プラグインと通信するためだけにFlutterEngineのすべての機械を起動する必要はないということですが、現時点では、必要なインフラストラクチャはすべてエンジンに関連付けられているため、現在はそのためです。 flutter_isolateは、プラグインにアクセスするためだけにエンジン全体を起動する必要があります。

（注：flutter_isolateは私のプラグインではありませんが、この機能も必要だったので、プロジェクトに貢献することにしました。）

申し訳ありませんが、これがフォークであることに気づきませんでした

flutter_isolateは、プラグインにアクセスするためだけにエンジン全体を起動する必要があります。

'is_background_view = true'を指定すると、エンジンはレンダリングを開始しません。つまり、エンジンは完全には開始されません。

ヘッドレスを実行するための正確なAPIは、iOSとAndroidv1およびAndroidv2で異なりますが、基本的にこれはflutter_isolateがすでに行っていることです。 ただし、通常の分離とFlutterEngineの間にはまだオーバーヘッドの違いがあるため、オーバーヘッドをさらに下げることは、Flutterチームが実行できることだけです。 これは、起動時のオーバーヘッドだけでなく、メモリ使用量のオーバーヘッドでもあります。

では、バックグラウンドで動作するように新しいエンジンの作成を最適化することを提案しますか？

次に、これはおそらくこの問題には当てはまりません

私はそれを示唆しているのではなく、回避できないオーバーヘッドのために、flutter_isolateの回避策にはこの制限があることを指摘しているだけです。 Flutterチームが回避策をより効率的にするように努めるべきだと言っているのではありません。理想的には、FlutterEngineをインスタンス化する必要がないように、プラグインのロード方法にアーキテクチャ上の変更があると思います。

エンジンが1で、分離が1より大きい場合、次の質問に戻ります。

https://github.com/flutter/flutter/issues/13937#issuecomment -667314232

私はこの新しい軽量アーキテクチャのソリューションを実際に考え出そうとはしていませんが、あなたが私に尋ねているのであれば、軽量ソリューションの2つのバリエーションを考えることができます。

1. メソッドチャネルを複数のクライアントからの接続を受け入れるようにすることで、サーバーソケットに少し似たものにします。 したがって、プラグインのプラットフォーム側のメソッドチャネルは、複数の分離からの接続を受け入れることができ、接続されると、適切な分離にメッセージを送信できます。
2. 同じFlutterEngine内で、分離ごとに新しいプラグインレジストリなどを作成します。

あなたが私に尋ねているなら

はい、お願いします

適切な分離にメッセージを送信できます。

「適切な分離」は相​​対的な概念であるため、これは悪い解決策だと思います

同じFlutterEngine内で、分離ごとに新しいプラグインレジストリなどを作成します。

これは良いオプションかもしれませんが、エンジンが常にプラグインをそれ自体で登録する場合に限ります。

ただし、これは、GeneratedPluginRegistrant内のすべてのプラグインの場合にのみ発生します。
https://github.com/flutter/engine/blob/f7d241fd8a889fadf8ab3f9d57918be3d986b4be/shell/platform/android/io/flutter/embedding/engine/FlutterEngine.java#L330 -L344

追加のコールバックを作成することは明らかな動作ではありません。

「適切な分離」は相​​対的な概念であるため、これは悪い解決策だと思います

それは悪い解決策かもしれませんが、その理由で悪いことはあり得ません。 「正しい分離」は、サーバーソケットがクライアント接続を明確な方法で処理するのと同じように明確です。

これは良いオプションかもしれませんが、エンジンが常にプラグインをそれ自体で登録する場合に限ります。

これは、常に発生することを保証するために良いことです。 現在、メカニズムは少し不安定です。

それは悪い解決策かもしれませんが、その理由で悪いことはあり得ません。 「正しい分離」は、サーバーソケットがクライアント接続を明確な方法で処理するのと同じように明確です。

次に、各プラグインは、異なる分離からアクセスできることを考慮に入れる必要があります-悪い

うん。

この議論に私の2セントを追加しましょう...約2年間Flutterと商業的に協力してきた中で、私が学んだ最も重要なことは、 FlutterがUIツールキットであることでした。 人々がこれを忘れていなければ、この声明には驚くべきことは何もありません-それはメインのFlutterウェブサイトでさえそう言っています-。

FlutterはUIツールキットであり、それがうまく機能するのはUIです。 高価なデータ処理に依存する、または複雑なアルゴリズムを使用し、大量のデータを消費するCPU負荷の高いアプリケーションを作成しようとしている場合は、この目的でUIツールキットを使用しないでください。 ビジネスロジックをUIと混在させないでください。

もちろん、Dartを使用すると、UIだけでなく、それ以上のことができますが、このツールキットの主な目的を忘れないでください。

ヘッドレスフラッターを使用するなど、さまざまなアプローチを試しましたが、これは完全な災害であることが判明しました。 それが機能しないからではなく、他の開発者にそれがどのように機能するかを説明するのに問題があるからです。 それが合計するメンテナンス負担は、それだけの価値がありません。 そのようなソリューションのテストについても言及しないでください。 前回試したとき、FlutterDriverはそれをまったく処理しませんでした。

アプリケーションが本当に処理能力を必要とする場合、IMHOには、次の3つのオプションがあります。

• ロジックをサーバーに移動します。
• ロジックをネイティブプラットフォームに移動し（これにはKotlin Nativeを使用できます）、イベント/メソッドチャネルを使用してビューモデルのみをUIに提供します（OLXが行ったことはそれだと思います：https：//tech.olx.com/fast -prototypes-with-flutter-kotlin-native-d7ce5cfeb5f1）;
• Flutterを使用せず、別のフレームワークを探してください（C＃はDartよりも洗練されたマルチスレッド環境を提供するため、Xamarin / Blazorがこれに適している可能性があります）。

上記のすべてに欠点がありますが、ライブラリ/フレームワークを拡張して、実際には設計されていないことを実行しようとすることも理想的ではありません。

Isolate_handlerはこの問題を解決しませんでしたか？

@hasonguoバックグラウンドでflutter_isolateを使用します。通信用のボイラープレートを追加することで、分離（実際には任意の分離）の処理を容易にする追加のレイヤーを追加するだけなので、毎回手動で設定する必要はありません。時間。 以前は別の方法で問題に対処していましたが、Flutter自体の変更によって不可能になり、代わりにflutter_isolateに依存するように変更されました。

私たちは輪になって行きます。 はい、解決策があります。実際には両方のプラグインです。 ライアンが指摘したように、チャネル通信を可能にすることにはオーバーヘッドが伴います。 多くの場合（ほとんどの場合）、サポートが必要ないため、Flutterチームが元のIsolateに自動的に追加することを回避したのはまさにこのオーバーヘッドです。

それでも、それはそれが得ることができるほどきれいな解決策ではありません。 Flutterチームが、オーバーヘッドなしで、直接かつ自動的に、基本的なIsolateを使用して、箱から出してすぐにチャネル通信を提供できるとしたら、議論全体は議論の余地があります。 ただし、その逆も当てはまります。つまり、変更のために実際に変更を追求しているわけではありません。 パッケージまたはプラグインに実行可能なソリューションがある場合、なぜ時間をかけてコアに重みを加えるのですか？

同じFlutterEngine内で、分離ごとに新しいプラグインレジストリなどを作成します。

これは良いオプションかもしれませんが、エンジンが常にプラグインをそれ自体で登録する場合に限ります。

ただし、これは、GeneratedPluginRegistrant内のすべてのプラグインの場合にのみ発生します。
https://github.com/flutter/engine/blob/f7d241fd8a889fadf8ab3f9d57918be3d986b4be/shell/platform/android/io/flutter/embedding/engine/FlutterEngine.java#L330 -L344

追加のコールバックを作成することは明らかな動作ではありません。

この2番目のアイデアのもう1つの改善点は、プラグインを新しい分離で遅延ロードすることです。 通常、プロジェクトが多くのプラグインに依存している場合、 GeneratedPluginRegistrantは非常に大きくなり、プラグインの初期化ルーチンの効率によっては、これがオーバーヘッドの一部に寄与する可能性があります。 正確にこれを実装する方法は別の話です。 プラットフォームチャネルはプラグインによって所有されていないため、現在、チャネルを介してメッセージを送信することを使用して、プラグインのプラットフォーム側をインスタンス化することはできません。 したがって、メソッドチャネルをプラグインに関連付けるか、プラグインのDart側が最初のメソッドチャネルが作成される前にそれ自体を遅延的に初期化するために呼び出すことができる追加のメカニズムが必要であり、そのメカニズムがインスタンス化をトリガーする可能性があります分離内のそのプラグインのプラットフォーム側の。

@TahaTesser

あなたの例では、エラーはこの問題とは関係ありません

E/flutter ( 7814): [ERROR:flutter/lib/ui/ui_dart_state.cc(177)] Unhandled Exception: Invalid argument(s): Isolate.spawn expects to be passed a static or top-level function

こんにちは@nikitadol
おかげで、更新された例、それは例外をスローしません、それは正しいですか？ （以前は使用する必要がありませんでした）
完全に再現可能な最小限のコードサンプルを提供していただけますか
ありがとう

@TahaTesser

import 'package:battery/battery.dart';
import 'package:flutter/foundation.dart';
import 'package:flutter/widgets.dart';

Future<void> main() async {
  await printBatteryLevel();
  await compute(printBatteryLevel, null);
}

Future<void> printBatteryLevel([dynamic message]) async {
  WidgetsFlutterBinding.ensureInitialized();
  print(await Battery().batteryLevel);
}

Launching lib/main.dart on Pixel 4 in debug mode...
Running Gradle task 'assembleDebug'...
✓ Built build/app/outputs/flutter-apk/app-debug.apk.
Installing build/app/outputs/flutter-apk/app.apk...
Waiting for Pixel 4 to report its views...
Debug service listening on ws://127.0.0.1:50709/-SPs_6AmL2Q=/ws
Syncing files to device Pixel 4...
I/flutter ( 8708): 39
E/flutter ( 8708): [ERROR:flutter/lib/ui/ui_dart_state.cc(166)] Unhandled Exception: Exception: UI actions are only available on root isolate.
E/flutter ( 8708): #0      Window._nativeSetNeedsReportTimings (dart:ui/window.dart:1003:86)
E/flutter ( 8708): #1      Window.onReportTimings= (dart:ui/window.dart:996:29)
E/flutter ( 8708): #2      SchedulerBinding.addTimingsCallback (package:flutter/src/scheduler/binding.dart:272:14)
E/flutter ( 8708): #3      SchedulerBinding.initInstances (package:flutter/src/scheduler/binding.dart:209:7)
E/flutter ( 8708): #4      ServicesBinding.initInstances (package:flutter/src/services/binding.dart:27:11)
E/flutter ( 8708): #5      PaintingBinding.initInstances (package:flutter/src/painting/binding.dart:23:11)
E/flutter ( 8708): #6      SemanticsBinding.initInstances (package:flutter/src/semantics/binding.dart:24:11)
E/flutter ( 8708): #7      RendererBinding.initInstances (package:flutter/src/rendering/binding.dart:32:11)
E/flutter ( 8708): #8      WidgetsBinding.initInstances (package:flutter/src/widgets/binding.dart:257:11)
E/flutter ( 8708): #9      new BindingBase (package:flutter/src/foundation/binding.dart:59:5)
E/flutter ( 8708): #10     new _WidgetsFlutterBinding&BindingBase&GestureBinding (package:flutter/src/widgets/binding.dart)
E/flutter ( 8708): #11     new _WidgetsFlutterBinding&BindingBase&GestureBinding&SchedulerBinding (package:flutter/src/widgets/binding.dart)
E/flutter ( 8708): #12     new _WidgetsFlutterBinding&BindingBase&GestureBinding&SchedulerBinding&ServicesBinding (package:flutter/src/widgets/binding.dart)
E/flutter ( 8708): #13     new _WidgetsFlutterBinding&BindingBase&GestureBinding&SchedulerBinding&ServicesBinding&PaintingBinding (package:flutter/src/widgets/binding.dart)
E/flutter ( 8708): #14     new _WidgetsFlutterBinding&BindingBase&GestureBinding&SchedulerBinding&ServicesBinding&PaintingBinding&SemanticsBinding (package:flutter/src/widgets/binding.dart)
E/flutter ( 8708): #15     new _WidgetsFlutterBinding&BindingBase&GestureBinding&SchedulerBinding&ServicesBinding&PaintingBinding&SemanticsBinding&RendererBinding (package:flutter/src/widgets/binding.dart)
E/flutter ( 8708): #16     new _WidgetsFlutterBinding&BindingBase&GestureBinding&SchedulerBinding&ServicesBinding&PaintingBinding&SemanticsBinding&RendererBinding&WidgetsBinding (package:flutter/src/widgets/binding.dart)
E/flutter ( 8708): #17     new WidgetsFlutterBinding (package:flutter/src/widgets/binding.dart)
E/flutter ( 8708): #18     WidgetsFlutterBinding.ensureInitialized (package:flutter/src/widgets/binding.dart:1229:7)
E/flutter ( 8708): #19     printBatteryLevel (package:bug/main.dart:11:25)
E/flutter ( 8708): #20     _IsolateConfiguration.apply (package:flutter/src/foundation/_isolates_io.dart:83:34)
E/flutter ( 8708): #21     _spawn.<anonymous closure> (package:flutter/src/foundation/_isolates_io.dart:90:65)
E/flutter ( 8708): #22     Timeline.timeSync (dart:developer/timeline.dart:163:22)
E/flutter ( 8708): #23     _spawn (package:flutter/src/foundation/_isolates_io.dart:87:35)
E/flutter ( 8708): #24     _startIsolate.<anonymous closure> (dart:isolate-patch/isolate_patch.dart:304:17)
E/flutter ( 8708): #25     _RawReceivePortImpl._handleMessage (dart:isolate-patch/isolate_patch.dart:168:12)
E/flutter ( 8708): 

[✓] Flutter (Channel stable, 1.20.4, on Mac OS X 10.15.6 19G2021, locale en-BY)
    • Flutter version 1.20.4 at /Users/nikitadold/development/flutter
    • Framework revision fba99f6cf9 (2 weeks ago), 2020-09-14 15:32:52 -0700
    • Engine revision d1bc06f032
    • Dart version 2.9.2

[✓] Android toolchain - develop for Android devices (Android SDK version 30.0.0)
    • Android SDK at /Users/nikitadold/Library/Android/sdk
    • Platform android-30, build-tools 30.0.0
    • Java binary at: /Users/nikitadold/Library/Application Support/JetBrains/Toolbox/apps/AndroidStudio/ch-0/193.6626763/Android Studio.app/Contents/jre/jdk/Contents/Home/bin/java
    • Java version OpenJDK Runtime Environment (build 1.8.0_242-release-1644-b3-6222593)
    • All Android licenses accepted.

[✓] Xcode - develop for iOS and macOS (Xcode 12.0.1)
    • Xcode at /Applications/Xcode.app/Contents/Developer
    • Xcode 12.0.1, Build version 12A7300
    • CocoaPods version 1.9.3

[!] Android Studio (version 4.0)
    • Android Studio at /Users/nikitadold/Library/Application Support/JetBrains/Toolbox/apps/AndroidStudio/ch-0/193.6626763/Android Studio.app/Contents
    ✗ Flutter plugin not installed; this adds Flutter specific functionality.
    ✗ Dart plugin not installed; this adds Dart specific functionality.
    • Java version OpenJDK Runtime Environment (build 1.8.0_242-release-1644-b3-6222593)

[✓] IntelliJ IDEA Ultimate Edition (version 2020.2.2)
    • IntelliJ at /Users/nikitadold/Applications/JetBrains Toolbox/IntelliJ IDEA Ultimate.app
    • Flutter plugin installed
    • Dart plugin version 202.7319.5

@TahaTesser
このコメントをご覧ください

プラットフォームメッセージは、メインの分離からのみサポートされます。 [...]

この動作は_期待_であり、ラベルsevere: new featureあります
この問題は、 _bug_ではなく_featurerequest_または_proposition_と見なす必要があります

@iapicca

あなたの例では、エラーはこの問題とは関係ありません

E/flutter (23174): [ERROR:flutter/lib/ui/ui_dart_state.cc(166)] Unhandled Exception: Invalid argument(s): Illegal argument in isolate message : (object is a closure - Function '<anonymous closure>':.)

@iapicca

あなたの例では、エラーはこの問題とは関係ありません

E/flutter (23174): [ERROR:flutter/lib/ui/ui_dart_state.cc(166)] Unhandled Exception: Invalid argument(s): Illegal argument in isolate message : (object is a closure - Function '<anonymous closure>':.)

あなたは正しいです私のものは良い例ではありません、それを無視してください