Flutter: 다른 격리에서 플랫폼 채널 메서드를 호출할 수 없습니다.

분류를 위한 cc @mravn-google

엔진 코드는 null을 역참조하고 보조 격리에서 플랫폼 메시지를 보내려고 할 때 충돌합니다. 나는 아직 정확히 어디를 지적하지 않았다; 나는 묘비를 얻었지만 그러한 것을 해석하는 방법을 배워야합니다.

(서투른) 해결 방법으로 두 번째 격리는 기본 격리에 메시지를 보내도록 요청할 수 있습니다.

@sroddy 2차 격리로 무엇을 하려는지 여쭤봐도 될까요?

다양한 사용 사례가 있습니다. 예:

• 엄청난 양의 데이터를 다운로드하고 구문 분석한 다음(dart:convert 메서드는 비동기식 아님) sqflite 플러그인(플랫폼 바인딩 사용)을 사용하여 sqlite db에 저장합니다.
• UI에 제공하기 전에 데이터를 미리 가져오고 구문 분석합니다.
• 암호화/암호 해독 및 파일에서 데이터 읽기/쓰기(암호화 작업은 플랫폼 보안 라이브러리를 사용하기 위해 메서드 채널을 통해 수행됨)

일반적으로 어떤 공개 메서드를 선언하는 종속성을 사용하여 결국에는 플랫폼별 코드를 사용하여 작업을 수행할지 여부를 알 수 없는 경우가 발생할 수 있습니다(예: flutterfire에 대해 생각하고 있습니다). 그것들을 사용하는 것은 돌로 쓰여진 것 대신에 시간이 지남에 따라 변할 수 있는 구현 세부 사항이어야 합니다.

데이터가 이미 메서드 채널에 전달되는 방식으로 인코딩되어 있기 때문에 해결 방법은 현재로서는 괜찮고 구현하기가 상대적으로 어렵지 않은 것 같습니다. 이러한 이유로 격리 포트를 통해서도 쉽게 전달되지만 성능은 차선책이 될 것입니다. .

그러나 구현하는 동안 약간 막혔습니다. 기본 격리에서 보조 메서드에서 정적 메서드를 호출하는 쉬운 방법의 예를 제공할 수 있습니까?

감사 해요

@sroddy 배경 정보를 제공해 주셔서 감사합니다.

기본 격리에서 정적 메서드 호출 정보: 직접 지원되지 않으며 포트를 사용하여 구현해야 합니다. 이 패키지 는 해당 기능을 제공할 수 있습니다(예: here . 그래도 직접 시도하지는 않았습니다.

그러나 여기서 우리는 플랫폼 채널 통신이 플러그인 또는 기타 라이브러리 구현의 일부로 수행될 때도 작동하는 보다 일반적인 솔루션을 찾아야 합니다.

아직 이에 대한 후크가 없지만 기본 격리가 아닌 보조 격리에서 사용할 알려진 채널 이름 세트 가 있다고 잠시 가정할 수 있다면 일반적으로 다음을 수행할 수 있어야 합니다. 해당 채널에 대해 플랫폼 메시지 처리를 재구성하고 두 격리 간에 필요한 바이너리 메시지 및 응답 전달을 투명하게 구현합니다. 플러그인은 그 차이를 결코 알지 못할 것입니다.

솔루션은 아래에 스케치되어 있습니다.

기본 격리에 포트 M1 및 R1을 설정하고 보조 격리에 M2, R2를 설정한다고 가정합니다. M은 메시지, R은 답장입니다.

• 2차 격리에서 각 채널에 대해 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 플랫폼 모두에 대해 구현되어야 하므로 플랫폼 측에서 작업을 두 배로 늘리는 스레드 또는 서비스를 만드는 것을 피하고 싶습니다. 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 from dart를 실행할 때 기본 라이브러리가 연결되지 않는다고 가정합니다.

예를 들어, 자바에서 플러터 코드를 실행할 때 이 메소드가 호출됩니다:

   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)

그런 다음 몇 가지 "dart isolates"를 얻습니다.

우리는 또한 이 문제에 직면해 있습니다. 우리는 모두 플랫폼 채널에 의존하는 배경 격리(예: 위치, 소음 등)에서 데이터를 수집해야 합니다. @mravn-google -- 이 문제를 해결할 수 있는 API 업데이트에 대한 소식이 있습니까?

도구나 미디어 앱에서는 정말 심각한 문제입니다.
플랫폼 스레드는 쉬운 방법이 아닙니다.

나는 또한 비슷한 문제에 직면하여 지금 막혔습니다.

+1(내 프로젝트도 격리된 플랫폼 채널이 심하게 필요함)

배경에서 이미지를 렌더링해야 합니다. 각 이미지는 몇 초가 걸리고 메인 스레드에서 수행되는 경우 UI를 차단하기 때문에 격리에서 수행해야 합니다. 나는 dart:ui.PictureRecorder 의 첫 번째 기본 호출에 갇혀 있고 각각의 모든 그래픽 호출(기본 기능을 사용하는)도 작동하지 않을 것이라고 가정합니다. 캔버스에서 많은 기능을 사용하기 때문에 콜백 포트로 작업하는 것은 고통스러울 것입니다.

솔루션을 높이 평가합니다.

+1 이 문제가 있습니다

@mravn-google이 오르후스에서 Google 작업을 중단한 것 같습니다. 이에 대해 조사하고 있는 Google Flutter 팀의 다른 사람이 있는지 궁금합니다. IMO, 이것은 탄력적이고 강력한 Flutter 애플리케이션을 구축하기 위해 Flutter를 진지하게 사용하기 위한 주요 쇼 스토퍼입니다....

@sethladd 가 상태를 제공할 수 있습니까?

+1

이에 대한 업데이트가 있습니까?

+1

스스로 해결하는 방법은 알지만 기다리기만 하면 되는 버그를 만난 날이 플러터 엔지니어가 될 때까지의 마지막 희망입니다.

새로운 flutter/dart 사용자를 위한 해결 방법에 대한 자세한 설명이 필요합니다. 나는 이틀 전에 isolates를 사용하기 시작했고 지난 주에 flutter/dart를 사용하기 시작했습니다. 그리고 몇 가지 심각하게 노동 집약적인 작업에 메인 스레드를 사용해야 하는 것처럼 보입니다. 따라서 학습 플러터가 나쁜 솔루션이 됩니다. 사용 가능한 멀티스레딩이 없으면 Kotlin을 배우고 앱을 두 번 빌드하는 것이 좋습니다. 여러분 모두가 초보자가 이해할 수 있는 것을 함께 얻을 수 있기를 바랍니다. 직장에서 사용할 수 있도록 플러터 학습을 고용주에게 정당화할 수 있기를 정말 바랍니다.
여기에 없다면 아마도 StackOverflow에 질문을 게시했습니다: https://stackoverflow.com/q/57466952/6047611

+1 곧 수정되기를 바랍니다.

+1 내 프로젝트는 격리된 플랫폼 채널이 필요합니다.

이 동일한 문제가 발생하여 @mravn-google이 게시한 것과 유사한 해결 방법을 사용하여 패키지( Isolate Handler )를 만들었습니다. 그러나 격리 처리기를 사용하면 다른 격리와 함께 기본 격리의 채널을 모두 사용할 수 있습니다. 격리 내에서 직접 MethodChannel 호출을 지원하지만 현재 EventChannel 스트림은 지원되지 않습니다. 사람들이 필요로 하는 것으로 판명되면 지원을 추가하는 방법을 살펴보겠습니다.

해결 방법의 한 가지 단점은 격리 처리기에 채널 이름을 제공해야 한다는 것입니다. 내 네이티브 코드를 직접 작성하고 있기 때문에 내 프로젝트에서는 문제가 되지 않지만, 그렇지 않으면 플러그인을 찾기 위해 사용 중인 플러그인의 소스 코드를 살펴봐야 합니다.

위에 이미 게시된 또 다른 옵션은 FlutterIsolate 입니다. 이 옵션은 다른 접근 방식을 사용하며 살펴볼 가치가 있습니다.

Flutter 개발자가 곧 이 문제에 대한 완전하고 적절한 솔루션을 제공할 수 있기를 바랍니다.

편집하다:

결국 Flutter 자사 Android 알람 관리자 플러그인과 유사한 접근 방식을 사용하는 대신 기본 측에서 격리를 시작하여 문제를 더 깔끔하게 해결했습니다.

내가 해야 하는 유일한 일은 네이티브 코드를 플러그인으로 변환하여 네이티브 애플리케이션에 등록할 수 있도록 하는 것뿐이었습니다. 이는 비교적 쉬운 마이그레이션이었습니다. pub.dev의 플러그인을 사용하는 경우 원활하게 작동해야 하므로 훨씬 더 간단합니다.

+1 업데이트가 있습니까?

+1

여기서 내가 주목하는 흥미로운 점은 다음과 같습니다.
여러 플러그인은 메소드 채널 호출이 Dart에서 백그라운드 스레드로 메시지를 전달한다는 가정 하에 작성된 것 같습니다. 이와 관련하여, 그 bg 지오펜싱 예제를 따랐고 이제 메인 스레드로 돌아가는 방법을 궁금해하는 매우 혼란스러운 사람들이 있습니다...
해당 플러그인 코드는 짧은 작업을 수행하는 경우 "버벅거림"을 일으키지 않지만 기본적으로 Android에서는 "UI 스레드"라고 하던 플랫폼 스레드 에서 실행됩니다. 이렇게 하면 작업량이 많을 때 제스처가 중단될 수 있으며 다른 모든 메시지 채널도 차단할 수 있음을 이해합니다.
그런 다음 플러그인 작성자의 엔지니어링에 종속됩니다. 네이티브 코드의 다른 스레드로 무거운 작업을 이동한 경우에만 메서드 채널을 기다리는 코드를 실행하게 됩니다. 이러한 메시지 채널 은 플랫폼 스레드에서 실행되어야 합니다.
나는 좋은 친메이가르드가 여기에 관련된 근거를 이해하지만 다음과 같이 동의합니다.

• 대부분의 플랫폼 API 호출은 빠르며 종종 메인 스레드에서 이루어져야 합니다.
• 네이티브 코드의 스레드를 고려하는 것이 더 합리적입니다.
• 프레임워크 메서드 재정의에서 "메인 스레드"로 돌아가는 방법을 찾는 것은 Android Java에 익숙한 사람들에게 분명히 혼란스럽습니다.
  
  
  
  • 플랫폼 스레드 전용 API를 처음으로 호출할 때 그 수가 얼마나 늘어날지 상상할 수 있습니다.
  
  

결과 아키텍처가 플러그인 작성자를 위한 기본값으로 중요한 안티 패턴을 열었다고 생각합니다. 언뜻보기에는 Firebase ml 플러그인조차도 처리를 위해 플랫폼 스레드를 사용한다고 생각합니다.
그래서 무거운 물건을 드는 사람들에게 어떤 종류의 강력한 경고가 주어졌으면 합니다. 메시지 채널 호출이 반환되는 데 ~20ms보다 오래 걸리는 경우 화면 오류를 생성하는 기본 예제 앱의 문제일 수 있습니다. 솔직히 말해서, db 호출 &c를 만드는 사람들을 설득하는 것이 무엇이든간에. 스레드를 이미 받으러 갑니다.

아, 공짜 점심은 없다, 그건 확실히...

Java와 Swift를 사용하여 네이티브 플랫폼 스레드로 무거운 워크로드를 구현하게 되었습니다. 해결 방법을 찾지 못했습니다.

@AndruByrne 이것은 참으로 매우 흥미로운 정보이며 지금 돌이켜 보면 명백해 보이는 것처럼 나는 그것을 알지 못했습니다. 사용자가 백그라운드에서 무거운 작업을 수행하는 방법으로 플러그인을 사용하려고 하여 UI가 잠긴 내 플러그인과 관련된 문제가 이미 하나 있습니다.

나는 경고가 있어야 한다는 데 동의하고 내 플러그인에 경고를 추가할 것입니다.

+1이 필요합니다

불행히도 - Flutter는 매우 기본적이지만 매우 중요한 것이 부족하기 때문에 황금기를 맞이할 준비가 되어 있지 않습니다. 모든 Flutter 앱이 간단한 async/await를 사용할 수 있는 것은 아닙니다. 무거운 작업을 위해서는 격리가 필수적이며 다른 격리에서 플랫폼 채널 메서드 호출을 허용할 수 없는 플러그인은 그것들을 무의미하고 중복되게 만듭니다. 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 연결에 대해 거의 멈췄습니다.

ㅋㅋㅋㅋㅋㅋㅋㅋㅋ!!!!!!!!!!!!!!!!!?!?!?

이 플러그인은 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.io API를 사용하여 methodchannel을 호출하고 있지만 속도가 너무 느리고 Flutter UI가 정지되어 여기에 컴퓨팅을 추가하고 싶었지만 동일한 오류가 발생했습니다.

이 문제를 해결하려면 어떻게 해야 하나요?

저도 방금 이걸로 넘어왔습니다. 저는 새 앱의 프로토타입을 만들고 있는데, 실제로 이 문제는 저에게 가장 큰 충격을 줄 수 있고 Flutter가 아닌 다른 솔루션을 살펴보게 하여 저를 슬프게 만들 것입니다.

이 문제에 대한 응답의 양이 알 수 있듯이 이것은 주요 문제이며 Flutter 앱의 컨텍스트에서 격리의 주요 사용 사례를 거의 무효화합니다.

저도 방금 이걸로 넘어왔습니다. 저는 새 앱의 프로토타입을 만들고 있는데, 실제로 이 문제는 저에게 가장 큰 충격을 줄 수 있고 Flutter가 아닌 다른 솔루션을 살펴보게 하여 저를 슬프게 만들 것입니다.

이 문제에 대한 응답의 양이 알 수 있듯이 이것은 주요 문제이며 Flutter 앱의 컨텍스트에서 격리의 주요 사용 사례를 거의 무효화합니다.

예, 이것은 큰 문제입니다. 최대한 빨리 수정해야 합니다.

나는 10일 동안 플러터를 배웠고 지금까지 그것을 사랑하지만 잠시 실험한 후에 문제가 발생하기 시작하고 단점을 보기 시작합니다. 이 문제는 2018년 1월 5일부터 열렸습니다.

이 버그를 수정하십시오.

곧 지원하기를 바랍니다.

@jpsarda , @klaszlo8207 숨 참지 마세요. 그리고 예, 오늘까지 문제에 대한 해결책이 있었습니다: https://pub.dev/packages/isolate_handler. 프로그래머는 Flutter의 최근 변경(몇 일 전)으로 인해 더 이상 해당 경로를 따라갈 수 없었기 때문에 오늘 플러그를 뽑아야 했습니다.

그러나 이것이 실제로 병렬 처리를 의미하지는 않는다는 것을 알아야 합니다. 모바일 앱에서는 그렇게 보일 수 있고 모양이 중요하지만 플랫폼 코드는 어쨌든 메인 스레드에서 실행되므로 격리에서 메인 스레드로 긴 작업을 다시 위임해도 실제로 아무 것도 달성하지 못했습니다.

비동기 기능을 사용할 때마다 기본적으로 다중 스레딩을 처리하는 다트가 있으면 좋을 것입니다.

@spiderion Async는 다른 많은 플랫폼과 마찬가지로 멀티스레딩을 의도하지 않았습니다. 저를 오해하지 마세요. 플랫폼 채널 제한이 큰 문제가 아니라는 말은 하지 않겠습니다. 왜냐하면 (내 앱은 어제까지 언급한 플러그인과 함께 작동하고 있었고 이제 해결 방법을 찾아야 함) async/ await는 처음부터 멀티스레딩에 관한 것이 아니었습니다.

@zoechi 이 문제에 대한 업데이트가 있거나 수정할 계획이 있는지 알고 싶습니다.
감사합니다.

@spiderion 그들은 그것을 실제로 고칠 수 없으며 격리가 작동하는 방식을 따릅니다. 뒤에 UI 엔진이 없으므로 플랫폼 채널 통신이 없습니다. 그러나 도움이 되는 두 가지 플러그인이 있습니다.

• https://pub.dev/packages/flutter_isolate 는 자체 UI 지원을 생성하기 때문에 플러그인과 통신할 수 있는 대체 격리를 제공합니다(기술적으로만 보거나 처리해야 하는 것은 없음).

• https://pub.dev/packages/isolate_handler 는 최근 Flutter 변경으로 인해 이전 방식이 불가능하게 되었기 때문에 위의 패키지에 의존하도록 수정했습니다. flutter_isolate 자체가 아닌 이 패키지를 사용할 때의 이점은 처리 기능이 추가되고 여러 격리를 시작하고 추적할 수 있으며 격리와 기본 통신을 설정할 필요가 없다는 것입니다. 스레드(원래 스톡 Isolate 및 FlutterIsolate 모두 수동으로 수행해야 하는 작업)는 추상화되고 쉽게 사용할 수 있기 때문입니다.

나는 두 번째를 완벽한 성공으로 사용합니다. 사실, 나는 꽤 오랫동안 그것을 사용해 왔으며 Flutter의 주요 변경 사항이 왔을 때 내 앱도 망가졌다는 이유로 프로그래머가 새로운 솔루션으로 넘어가도록 도왔습니다. :-)

따라서 코어에서 솔루션을 기대하는 것이 합리적이지 않다고 생각합니다. 특히 대부분의 사용 사례는 플랫폼 채널 통신을 요구하지 않으므로 지원 UI 엔진은 모든 격리에 추가하고 싶은 것이 아닙니다. 추가 기능이 필요할 때 기존 플러그인을 사용하기만 하면 됩니다.

안녕하세요 @deakjahn 빠른 답변 감사합니다.

귀하가 제공한 솔루션은 매우 유용해 보입니다. 그러나 그것이 내 문제를 해결할 수 있는지 모르겠습니다. 현재 앱에서 사용자가 Instagram과 유사한 이야기를 만드는 상황이 있습니다. 이 경우 앱은 업로드하는 데 시간이 매우 오래 걸릴 수 있는 동영상 및 파일 목록(연결이 느린 경우 약 15분)을 Firebase 저장소에 업로드해야 하며, 파일이 업로드된 후 앱에서 생성해야 합니다. Firebase 클라우드, Firestore에 있는 문서입니다. 내가 만난 문제는 파일이 업로드되는 동안 사용자가 앱을 종료하면 전체 작업이 완전히 실행되지 않는다는 것입니다.

그것은 실제로 격리의 책임이 아니라 지시한 대로 수행할 뿐입니다. 내가 직접 사용한 적은 없지만 Firebase는 내가 볼 수 있는 한 중지된 언로드를 재개할 수 있습니다.

getBatteryLevel 예제를 실행하려고 합니다.
https://flutter.dev/docs/development/platform-integration/platform-channels?tab=android-channel-java-tab
Android 기기에서 실행하려고 할 때마다 충돌합니다. 누군가 도와주시겠습니까? 로그가 없고 무한 루프에서 계속 실행되고 정확히 동일한 코드를 사용하고 있기 때문에 오류를 확인하는 방법조차 모르겠습니다.

이 문제에 P5 레이블 지정 ??? 🥵

이전 댓글을 확인해주세요. 대부분의 격리에는 필요하지 않은 메커니즘이 필요하기 때문에 이것이 프레임워크에서 변경될 가능성은 매우 낮 습니다. 따라서 오버헤드를 추가하는 것은 의미가 없습니다. 필요한 경우 이를 해결하기 위한 패키지가 있습니다.

사용자는 메커니즘에 신경 쓰지 않습니다. 얼마나 힘든지 아닌지. 그들은 단지 결과가 필요합니다. 이것은 불가능할 수 있습니다. 하지만 사용자가 필요로 하면 Flutter에서 제공해야 합니다...

구현에 제한이 있으며 이 기능을 기존 격리에 추가하거나 이 기능을 사용하여 새 API를 만드는 데 많은 시간이 걸릴 수 있음을 이해합니다. 나는 이것이 P5보다 우선 순위가 높아야한다고 생각합니다.

또한 귀하의 의견을 모두 읽고 귀하가 만든 패키지를 홍보하는 것처럼 느낍니다.

아니요, 내가 만든 것은 아니지만 몇 주 전에 소유권을 수락했습니다. 나는 그것이 이 스레드에서 비밀로 유지되었다고 생각하지 않습니다. 그 외에도 원하는 것을 제공할 수 있는 두 개의 패키지(단일 게시물에서 실제로 한 번만)를 언급했으며 지금까지 수행한 뛰어난 작업에 의존하는 것 외에 두 번째 패키지와 아무 관련이 없습니다.

당신이 그것을 읽는다면, 내가 이것을 처음에 직접 사용한 유일한 이유는 당신이 요청한 것과 똑같은 기능이 필요했기 때문입니다. 그리고 내 앱은 1년 이상 문제 없이 사용하고 있습니다. 게다가, 가끔 개발자가 격리를 사용하는 것보다 격리의 내부 작동에 더 익숙해지면(또한 Flutter Web에서 해당 작업을 시작했다는 사실도 알게 되었습니다) 내가 쓴 내용이 사실이라고 생각하게 됩니다. 이 기능 은 포함에 반대하는 주장이 꽤 많기 때문에 프레임워크에 포함되었습니다. 시간이 많이 걸리기 때문이 아니라 전혀 아닙니다. 시간이 비교적 적게 소요될 것입니다. 단순히 일부만 실제로 필요하고 사용하는 것보다 모든 격리에 백엔드 복잡성을 추가하기 때문입니다.

@deakjahn 이 팁에 감사드립니다. isolate_handler를 사용하면 네이티브 측에서 알림을 받을 때마다 메서드를 호출하고 다트 측으로 데이터를 보내는 데 도움이 될까요? (저는 twilio 기본 SDK를 사용하고 있으며 기본 측에서 푸시 알림을 받고 있습니다)

이것이 플랫폼 채널을 통해 통신하는 데 사용하는 patform 플러그인이 있다는 것을 의미한다면 예, 두 패키지 중 하나가 도움이 될 것입니다. 일반 코드에서 작동하는 경우 이러한 패키지를 사용하면 격리에서도 작동합니다.

@deakjahn 빠른 답변 감사합니다! 내 문제는 일반 플랫폼 채널로 할 수 없다는 것입니다. 확실하지 않지만 twilio sdk는 메인 스레드가 아닌 별도의 격리에서 푸시 알림 수신을 처리한다고 생각합니다. 그것이 내 문제라고 생각합니다. 두 패키지 중 하나를 사용하여 알림을 받을 때마다 메서드를 호출하면 작동하는지 알고 싶었습니다. 감사합니다. (가능하지 않다면 기본 앱으로 전환하는 것을 고려하고 있습니다)

나는 Twilio가 무엇인지조차 알지 못하기 때문에 (OK, 나는 그것을 봤음 :-)), 그래서 나는 정말로 확신할 수 없습니다. 하지만 어쨌든 네이티브 코드를 인터페이스하려면 플랫폼 채널 을 사용해야 합니다. 이 Twilio를 사용하기 위해 만든 이미 존재하는 플러그인을 사용하거나 직접 작성합니다(이 경우 거의 동일한 플러그인을 만들고 게시하지 않고 로컬에서 참조). 또는 단순히 관련 플러그인을 복사합니다. 코드를 자신의 앱에 추가합니다(외부 종속성은 아니지만 그 외에는 실제로 동일한 코드를 갖습니다).

그리고 플랫폼 채널이 있는 경우 이전 답변이 적용됩니다. 일반 Flutter 앱의 메인 스레드에서 플랫폼 채널과 플러그인을 이미 사용할 수 있다면 다음 중 하나를 사용하여 격리에서 동일한 것을 사용할 수 있습니다. 두 개의 패키지.

따라서 이 문제는 2018년 1월 5일부터 존재하며 추가 노력으로 여전히 불가능합니다. 제공된 솔루션은 훌륭하지만 데스크탑에서는 아직 작동하는 것이 없습니다. 따라서 데스크탑에서 Flutter가 얼마나 잘 작동하는지 시험해보고 미래 제품에 대한 가능성이 있는지 확인하려는 사람은 여기에서 완전히 막히게 될 것입니다.
거의 모든 앱에 격리가 필요합니다. 항상 엄청난 계산이 있기 때문에 중요한 Api 설계 결함에 대해 아무 일도 일어나지 않을 수 있다는 것이 어떻게 가능한가요?

내 플러그인 시스템 경고 창 에 이에 대한 방법을 추가했습니다.

솔루션은 여기에 언급 되어 있습니다.
제공된 예제는 시스템 경고 창 플러그인과 관련이 있지만 다른 플러그인에서도 쉽게 복제할 수 있습니다. 그리고 그것을 작동시키기 위해 다른 멋진 플러그인이 필요하지 않습니다!

이것은 여전히 ​​문제가 될 수 있습니다. 플러그인으로 무엇이든 하려면 앱 범위에 메시지를 보내야 하기 때문에 백그라운드/포그라운드에서 실행 중인 격리에서 플러그인을 직접 호출할 수 있는 방법이 없음을 의미합니다. 따라서 앱이 실행되고 있지 않다면 백그라운드에서 플러그인으로 아무 것도 할 수 없습니다.

따라서 예를 들어 앱이 닫힐 때 FCM 플러그인의 backgroundMessageHandler에서 공유 기본 설정으로 무엇이든 하려는 경우 MissingPluginException이 발생합니다.

또는 시스템 경고 창으로 앱을 열지 않으려는 경우. 경고 창이 다른 격리에서 실행 중입니다. 따라서 앱 범위 내에서 코드를 실행해야 합니다. 앱이 현재 닫혀 있기 때문에 문제가 됩니다.

그리고 이것이 큰 문제인 다른 많은 시나리오가 있을 것입니다.

@michael-ottink 설명하는 시나리오는 정확히 문제가 없어야 하는 시나리오입니다. 백그라운드에서 코드를 실행하는 플러그인은 일반적으로 자체 플러그인 레지스트리를 사용하여 완전히 새로운 FlutterEngine을 인스턴스화하고 그 안에서 실행되는 격리는 플랫폼 채널을 통해 해당 플러그인과 직접 통신할 수 있습니다.

덧붙여서, 플러그인을 사용하기 위해 격리가 필요한 경우 쉬운 방법은 해당 격리를 FlutterEngine에 래핑하는 것입니다. 그러면 해당 권한을 마술처럼 상속받게 됩니다. 이것은 Android 및 iOS에서 flutter_isolate 패키지가 하는 일입니다(해결 방법보다 적절한 수정을 하는 것이 더 낫다는 데 동의합니다. 현재 사용 가능한 해결 방법에는 병목 현상, 오버헤드가 있거나 그렇지 않으면 유지 관리가 제대로 이루어지지 않거나 지원이 부족할 수 있습니다. 모든 플랫폼.)

@ryanheise so flutter_isolate 저한테 맞나요? 문서에서 어떻게 말할 수 없습니다. FCM onBackgroundMessage에서 작동하려면 어떻게 해야 합니까? 그래서 내 onBackgroundMessageHandler에서 새 격리를 생성해야 합니까? 하지만 거기에서 플러그인을 사용할 수 없으므로 flutter_isolate를 어떻게 사용합니까?

문제는 firebase_messaging이 오랫동안 업데이트되지 않았고 최신 백그라운드 실행 API보다 훨씬 뒤떨어져 있다는 것입니다. 그들이 플러그인을 업데이트했다면 더 이상 이 문제가 발생하지 않을 것입니다. 다시 명확히 하자면, 귀하가 설명하는 시나리오는 올바르게 구현된 경우 백그라운드 격리가 이미 플러그인에 액세스할 수 있어야 하기 때문에 문제가 없어야 하는 시나리오입니다. firebase_messaging 플러그인은 최신 API에 따라 구현되지 않았으므로 작동하지 않습니다. 해당 프로젝트와 함께 버그 보고서를 제출할 수 있습니다.

나는 이것에 대한 도움이 절실히 필요합니다. 내가 할 수있는 방법이 있습니까? 나는 내일 나의 첫 번째 진지한 거래가 있고 나는 그것을 이해할 수 없습니다.

플러그인이 로드되고 있는지 확인하기 위해 모든 작업을 수행합니다. 백그라운드 메시지를 활성화하는 방법에 대한 README의 지침을 따랐는지 모르겠지만 플러그인의 백그라운드 FlutterNativeView 초기화에 연결하는 사용자 지정 Application 클래스를 만들어야 합니다. 그렇게 하지 않으면 사용할 수 있는 플러그인이 없습니다. 그래도 작동하지 않으면 프로젝트를 이전 v1 스타일 플러그인 아키텍처로 다운그레이드할 수 있습니다(v2가 필요한 다른 플러그인이 중단될 위험이 있음).

내 Application.k를 다음과 같이 설정합니다.

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

이것을 테스트할 기회가 있습니까? 내 요구 사항에 맞는 경우 등 ..

@나일릭
이 파일을 교체하십시오(버전 1.17.5의 경우 실제).

```dart// Copyright 2014 The Flutter Authors. 판권 소유.
// 이 소스 코드의 사용은 BSD 스타일 라이선스의 적용을 받습니다.
// LICENSE 파일에서 찾았습니다.

가져오기 ' 다트:비동기 ';
가져오기 ' 다트:분리 ';
가져오기 ' 다트:typed_data ';
' dart:ui '를 ui로 가져옵니다.

가져오기 ' 패키지:flutter/foundation.dart ';

import 'asset_bundle.dart';
import 'binary_messenger.dart';
'system_channels.dart' 가져오기;

/// 플랫폼 메시지를 수신하고 [defaultBinaryMessenger]로 보냅니다.
///
/// [ServicesBinding]은 또한 노출하는 [LicenseEntryCollector]를 등록합니다.
/// 자산의 루트에 저장된 LICENSE 파일에서 찾은 라이선스
/// 번들로 제공되고 ext.flutter.evict 서비스 확장을 구현합니다(참조
/// [퇴거]).
BindingBase의 믹스인 ServicesBinding {
@우세하다
무효 initInstances() {
super.initInstances();
_instance = 이것;
_defaultBinaryMessenger = createBinaryMessenger();
window.onPlatformMessage = defaultBinaryMessenger.handlePlatformMessage;
초기화 라이선스();
SystemChannels.system.setMessageHandler(handleSystemMessage);
}

/// 생성된 경우 현재 [ServicesBinding]입니다.
정적 ServicesBinding get 인스턴스 => _instance;
정적 서비스 바인딩 _instance;

/// [BinaryMessenger]의 기본 인스턴스입니다.
///
/// 애플리케이션에서 플랫폼으로 메시지를 보내는 데 사용되며,
/// 각 채널에 등록된 핸들러를 추적하므로
/// 들어오는 메시지를 등록된 핸들러에 전달할 수 있습니다.
BinaryMessenger get defaultBinaryMessenger => _defaultBinaryMessenger;
BinaryMessenger _defaultBinaryMessenger;

/// 전송에 사용할 수 있는 기본 [BinaryMessenger] 인스턴스를 만듭니다.
/// 플랫폼 메시지.
@보호
BinaryMessenger createBinaryMessenger() {
반환 const _DefaultBinaryMessenger._();
}

/// [SystemChannels.system]에서 수신된 메시지에 대해 호출된 핸들러
/// 메시지 채널.
///
/// 다른 바인딩은 들어오는 시스템 메시지에 응답하기 위해 이것을 재정의할 수 있습니다.
@보호
@mustCallSuper
미래핸들 시스템 메시지(객체 시스템 메시지) 비동기 { }

/// [LicenseRegistry]에 관련 라이선스를 추가합니다.
///
/// 기본적으로 [ServicesBinding]의 [initLicenses] 구현은 다음을 추가합니다.
/// 컴파일하는 동안 flutter 도구에서 수집한 모든 라이선스.
@보호
@mustCallSuper
무효 initLicenses() {
LicenseRegistry.addLicense(_addLicenses);
}

개울_addLicenses() 비동기* {
// 여기에서 타이머를 사용합니다(스케줄러 바인딩의 scheduleTask 대신).
// 서비스 계층은 스케줄러 바인딩(스케줄러
// 바인딩은 서비스 계층을 사용하여 수명 주기 이벤트를 관리합니다. 타이머
// 이는 어쨌든 scheduleTask가 내부적으로 사용하는 것입니다. 유일한 차이점은
// 이것들은 상대적으로 우선 순위가 지정되는 대신 다음에만 실행됩니다.
// 실행 중일 수 있는 다른 작업. 여기에서 _무언가_를 사용하여 중단
// isolates를 복사하는 데 시간이 걸리기 때문에 이것을 두 부분으로 나누는 것이 중요합니다.
// 현재 데이터이고 동일한 이벤트 루프에서 데이터를 수신하는 경우
// 다음 격리로 데이터를 보낼 때 반복, 우리는 확실히
// 프레임을 놓치게 됩니다. 또 다른 솔루션은 모든 작업을
// 하나의 격리에서 발생하고 결국 거기에 갈 수 있지만 먼저
// 격리 통신을 더 저렴하게 만들 수 있는지 확인합니다.
// 참조: https://github.com/dart-lang/sdk/issues/31959
// https://github.com/dart-lang/sdk/issues/31960
// TODO(ianh): 이러한 버그가 수정되면 이 복잡성을 제거합니다.
최종 완성자rawLicenses = 완성자();
Timer.run(() 비동기 {
rawLicenses.complete(rootBundle.loadString('LICENSE', 캐시: false));
});
rawLicenses.future를 기다립니다.
최종 완성자> parsedLicenses = 완성자>();
Timer.run(() 비동기 {
parsedLicenses.complete(compute(_parseLicenses, rawLicenses.future 대기, debugLabel: 'parseLicenses'));
});
parsedLicenses.future를 기다립니다.
yield* 스트림.fromIterable(parsedLicenses.future를 기다립니다);
}

// 이것은 위의 _addLicenses에 의해 생성된 다른 격리에서 실행됩니다.
정적 목록_parseLicenses(문자열 rawLicenses) {
최종 문자열 _licenseSeparator = '\n' + ('-' * 80) + '\n';
최종 목록결과 =[];
최종 목록라이선스 = rawLicenses.split(_licenseSeparator);
for (라이센스의 최종 문자열 라이선스) {
최종 정수 분할 = license.indexOf('\n\n');
if (분할 >= 0) {
result.add(LicenseEntryWithLineBreaks(
license.substring(0, split).split('\n'),
license.substring(분할 + 2),
));
} 또 다른 {
result.add(LicenseEntryWithLineBreaks(const[], 라이선스));
}
}
반환 결과;
}

@우세하다
무효 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 도구에서 사용하므로 모든 이미지가
/// 디스크에서 변경된 사항은 캐시에서 지워집니다.
@보호
@mustCallSuper
무효 축출(문자열 자산) {
rootBundle.evict(자산);
}

미래스폰 격리(
미래또는entryPoint(T 메시지),
T 메시지, {
부울 일시 중지 = 거짓,
부울 오류가 치명적이고,
센드포트 온엑시트,
SendPort 오류,
문자열 디버그 이름,
}) {
주장하다(
_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,
);

}
}

미래_start격리(SendPort sendPort) 비동기 {
_sendPortToMainIsolate = sendPort;
_IsolateBinding();

최종 완성자<_IsolateStarter> 완성자 =
완성자<_IsolateStarter>();

최종 RawReceivePort 수신 포트 = RawReceivePort(
(객체 격리 시작) {
assert(isolateStarter는 _IsolateStarter입니다.);
completer.complete(isolateStarter를 _IsolateStarter로);
},
);

sendPort.send(receivePort.sendPort);

최종 _IsolateStarterisolateStarter = completer.future를 기다립니다.

수신포트.닫기();

최종 기능 함수 =
UI.PluginUtilities.getCallbackFromHandle(isolateStarter.callbackHandle);

함수(isolateStarter.message)를 기다립니다.
}

SendPort _sendPortToMainIsolate;

bool get _isMainIsolate => _sendPortToMainIsolate == null;

클래스 _IsolateStarter{
_IsolateStarter(this.callbackHandle, this.message);

최종 ui.CallbackHandle callbackHandle;
최종 T 메시지;
}

클래스 _메시지 {
_메세지(
this.채널,
이 메시지,
this.sendPort,
);

최종 문자열 채널;
최종 ByteData 메시지;
최종 SendPort sendPort;
}

클래스 _IsolateBinding은 ServicesBinding {}으로 BindingBase를 확장합니다.

/// [BinaryMessenger]의 기본 구현.
///
/// 이 메신저는 앱 측에서 플랫폼 측으로 메시지를 보내고
/// 플랫폼 측에서 들어오는 메시지를 적절한
/// 핸들러.
클래스 _DefaultBinaryMessenger는 BinaryMessenger를 확장합니다. {
const _DefaultBinaryMessenger._();

// 플랫폼 플러그인에서 들어오는 메시지 처리기.
// 이것은 이 클래스가 const 생성자를 가질 수 있도록 정적입니다.
정적 최종 지도_핸들러 =
{};

// 나가는 메시지를 가로채서 응답하는 모의 핸들러.
// 이것은 이 클래스가 const 생성자를 가질 수 있도록 정적입니다.
정적 최종 지도_mockHandlers =
{};

미래_sendPlatformMessage(문자열 채널, 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;

}

@우세하다
미래핸들플랫폼메시지(
스트링 채널,
바이트데이터 데이터,
ui.PlatformMessageResponseCallback 콜백,
) 비동기 {
ByteData 응답;
노력하다 {
최종 MessageHandler 핸들러 = _handlers[채널];
if (핸들러 != null) {
응답 = 핸들러(데이터)를 기다립니다.
} 또 다른 {
ui.channelBuffers.push(채널, 데이터, 콜백);
콜백 = null;
}
} catch(예외, 스택) {
FlutterError.reportError(FlutterErrorDetails(
예외: 예외,
스택: 스택,
라이브러리: '서비스 라이브러리',
컨텍스트: ErrorDescription('플랫폼 메시지 콜백 중'),
));
} 마지막으로 {
if (콜백 != null) {
콜백(응답);
}
}
}

@우세하다
미래send(문자열 채널, ByteData 메시지) {
최종 MessageHandler 핸들러 = _mockHandlers[채널];
if (핸들러 != null)
리턴 핸들러(메시지);
return _sendPlatformMessage(채널, 메시지);
}

@우세하다
무효 setMessageHandler(문자열 채널, MessageHandler 핸들러) {
if (핸들러 == null)
_handlers.remove(채널);
또 다른
_handlers[채널] = 핸들러;
ui.channelBuffers.drain(채널, (ByteData 데이터, ui.PlatformMessageResponseCallback 콜백) 비동기 {
handlePlatformMessage(채널, 데이터, 콜백)를 기다립니다.
});
}

@우세하다
무효 setMockMessageHandler(문자열 채널, MessageHandler 핸들러) {
if (핸들러 == null)
_mockHandlers.remove(채널);
또 다른
_mockHandlers[채널] = 핸들러;
}
}
```

나는 flutter 1.21을 가지고 있으므로 모든 코드를 업데이트하여 컴파일하려고 했습니다.
이제 _IsolateBinding이 BindingBase 메서드의 구현을 많이 누락했기 때문에 하나의 문제가 남았습니다...

나는 좋아한다

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;
}

@나일릭
현재로서는 flutter를 업데이트할 수 없습니다.

왜 flutter 팀에서 구현한 다른 flutter 도구(예: devtools)가 이 차단기를 치지 않았는지 궁금합니다.
그들은 그들에 의해 차단되었을 때만 버그를 수정하는 것처럼 보입니다.

이것은 심각한 새 기능이 아니라 프레임워크 차단기입니다.
따라서 https://github.com/flutter/flutter/issues/18761#issuecomment -639248761에 따르면 P3여야 합니다.

왜 flutter 팀에서 구현한 다른 flutter 도구(예: devtools)가 이 차단기를 치지 않았는지 궁금합니다.
그들은 그들에 의해 차단되었을 때만 버그를 수정하는 것처럼 보입니다.

솔직히 말해서 이 문제가 실제 앱에 미치는 영향이 과대평가되었다고 생각하기 때문입니다. 문제가 더 쉬워지기 때문에 지켜보고 있는 중이지만 "해결 방법"이 있습니다. 그리고 프로덕션의 많은 앱과 플러그인은 백그라운드 기능을 사용하고 있습니다.

+1 중 일부가 문제가 무엇인지 잘 이해하지 못하는지 확실하지 않습니다. (예: https://github.com/flutter/flutter/issues/13937#issuecomment-635683123 ). Imo 백그라운드 격리 및 헤드리스 런타임(및 관리 방법)에 대한 공식 문서는 여전히 약간 부족하고 Firebase 메시징 항목은 악몽이지만 프레임워크, 엔진과 관련이 없습니다 🤷‍♂️

그냥 플러터 팀 욕좀 그만하고, 놀라운 진전이 있고, 이건 돌이킬 수 없는 일이 아닙니다... 그리고 PR이 있다면 플러터 팀이 고려할 수 있도록 제출하는 것이 어떨까요 🤔

격리에 대해 이 동작을 구현하는 데 문제가 있습니다.

예시:

메인 아이솔레이트와 엔진이 있습니다.
격리에 필요한 것이 있으면 엔진에 요청합니다.
엔진에 필요한 것이 있으면 격리를 요청합니다.

이제 우리의 상황은 다음과 같습니다.
2개의 격리 장치와 엔진이 있습니다.
격리에 필요한 것이 있으면 엔진에 요청합니다.
엔진에 무언가가 필요한 경우 어떻게 해야 합니까?
둘 다 물어? 그러면 누구의 대답을 취해야 할까요?
아니면 하나의 분리물만 요청하시겠습니까? 그럼 어느 쪽?

@hpoul 여기에 있는 많은 사람들이 Android/ios 프로그래밍의 초보자이고 앱 개발을 위한 첫 번째 프레임워크를 선택했기 때문에 동의해야 합니다.

따라서 누군가가 이것을 깨닫고 프레임워크에 의해 차단되고 강제로 복잡한 "해결 방법"을 수행해야 하는 이러한 종류의 문제에 대한 예를 통해 공식 해결 방법을 수정하거나 제안하는 것이 중요합니다. 여기나 stackoverflow 또는 다른 블로그의 주석에 잘 설명된 해결 방법이 없기 때문에 어디서부터 시작해야 할까요? 이것을 올바르게 구현했거나 구현하지 않았을 수 있는 일부 패키지를 가리키는 항목만 있습니다.

Android와 ios 모두 에서 서비스, 백그라운드 작업 대기열 등으로 작업한 경험이 많고 이 문제를 쉽게 해결할 수 있는 사람들은 flutter의 대상 인구 통계가 아닙니다.

그리고 다른 모든 문제에는 잘못된 +1이 있다고 확신합니다. 이는 문제 우선 순위의 순서를 크게 변경하지 않으며 이 문제는 여전히 맨 위에 있습니다.

안녕하세요 @phanirithvij

flutter_isolate는 위에 링크되었으며 2019년 2월부터 사용되었습니다. 또한 복잡하지 않습니다. 간단해 보이는 README를 복사하겠습니다.

FlutterIsolate를 사용하면 플러터 플러그인을 사용할 수 있는 플러터에서 격리를 생성할 수 있습니다. 플랫폼 채널이 격리 내에서 작동할 수 있도록 필요한 플랫폼별 비트(Android의 FlutterBackgroundView 및 iOS의 FlutterEngine)를 생성합니다.

| | 안드로이드 | iOS | 설명 |
| :-------------------- | :----------------: | :--------------------------------: | :-------------------------------- |
| FlutterIsolate.spawn(entryPoint, 메시지) | :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 팀이 더 나은 작업을 수행할 수 있다고 확신하는 이유 중 하나입니다. 마찬가지로 기본 격리를 통해 모든 플러그인 메서드 호출을 파이핑하는 대체 솔루션은 애초에 격리의 목표에 반대되는 병목 현상을 생성하므로 Flutter 팀도 이 작업을 더 잘 수행할 수 있을 것이라고 확신합니다.

Flutter 팀이 먼저 해결해야 할 더 높은 우선순위 문제가 있을 수 있다고 말한 사람들의 의견에 동의하지만, 플러그인 아키텍처에서 이전에 본 것을 기반으로 하면 이 문제를 수정하려면 주요 아키텍처 변경 및 기타 몇 가지 미해결 문제가 필요할 수도 있습니다. 또한 주요 아키텍처 변경이 필요하며 이러한 모든 요구 사항을 평가하는 데는 이 특정 문제를 해결하기까지 시간이 걸릴 수 있습니다.

@ryanheise

flutter_isolate는 각 격리에 대해 별도의 엔진을 만듭니다.

그래서 저는 Flutter 팀도 그 일을 더 잘 할 수 있다고 확신합니다.

Flutter 팀이 이것을 할 수 있다고 말하지만 어떻게?
위에서 질문한 내용은 유효합니다.
솔루션이 새 엔진을 만드는 것이라면 플러그인을 사용하면 됩니다.

(참고로 flutter_isolate는 내 플러그인이 아니지만 이 기능도 필요했기 때문에 프로젝트에 기여하기로 결정했습니다.)

"더 나은 작업"이 의미하는 바는 플러그인과 통신하기 위해 FlutterEngine의 모든 기계를 가동할 필요는 없지만 현재 필요한 인프라가 모두 엔진에 연결되어 있으므로 현재 flutter_isolate는 플러그인에 액세스하기 위해 전체 엔진을 가동해야 합니다.

(참고로 flutter_isolate는 내 플러그인이 아니지만 이 기능도 필요했기 때문에 프로젝트에 기여하기로 결정했습니다.)

죄송합니다. 이것이 포크인 줄 몰랐습니다.

flutter_isolate는 플러그인에 액세스하기 위해 전체 엔진을 가동해야 합니다.

'is_background_view = true'로 지정하면 엔진이 렌더링을 시작하지 않습니다. 즉, 엔진이 완전히 시작되지 않습니다.

헤드리스 실행을 위한 정확한 API는 iOS, Android v1 및 Android v2에서 다르지만 본질적으로 이것이 flutter_isolate가 이미 하는 일입니다. 일반 격리와 FlutterEngine 사이에는 여전히 오버헤드의 차이가 있으므로 오버헤드를 더 낮추는 것은 Flutter 팀이 할 수 있는 유일한 것입니다. 시작 시간의 오버헤드일 뿐만 아니라 메모리 사용의 오버헤드이기도 합니다.

그래서 백그라운드에서 작동하도록 새 엔진 생성을 최적화하는 것이 좋습니다.

그렇다면 이것은 아마도 이 문제에 적용되지 않을 것입니다

나는 그것을 제안하는 것이 아니라, 단지 flutter_isolate 해결 방법이 피할 수 없는 오버헤드 때문에 이 제한이 있음을 지적하는 것입니다. Flutter 팀이 해결 방법을 더 효율적으로 만들어야 한다고 제안하는 것은 아닙니다. 이상적으로는 FlutterEngine을 인스턴스화할 필요가 없도록 플러그인이 로드되는 방식에 아키텍처 변경이 있을 것이라고 생각합니다.

엔진이 1이고 격리가 1보다 크면 이 질문으로 돌아갑니다.

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

이 새로운 경량 아키텍처에 대한 솔루션을 실제로 생각해내려고 하는 것은 아니지만 저에게 묻는다면 경량 솔루션의 두 가지 변형을 생각할 수 있습니다.

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 이상의 작업을 수행할 수 있지만 이 툴킷의 주요 목적을 잊지 말자.

저는 헤드리스 Flutter를 사용하는 것을 포함하여 여러 가지 접근 방식을 시도했지만 완전히 재앙으로 판명되었습니다. 작동하지 않아서가 아니라 다른 개발자에게 작동 방식을 설명하는 데 문제가 있기 때문입니다. 추가되는 유지 관리 부담은 그만한 가치가 없습니다. 그러한 솔루션을 테스트하는 것은 말할 것도 없습니다. 마지막으로 시도했을 때 Flutter Driver는 전혀 처리하지 못했습니다.

애플리케이션에 처리 능력인 IMHO가 정말로 필요한 경우 세 가지 옵션이 있습니다.

• 논리를 서버로 이동하십시오.
• 논리를 기본 플랫폼으로 이동합니다. 이를 위해 Kotlin Native를 사용할 수 있습니다. 그리고 이벤트/메서드 채널을 사용하여 UI에 View Models만 제공합니다(OLX가 한 일이라고 생각합니다: https://tech.olx.com/fast -플러터가 있는 프로토타입-kotlin-native-d7ce5cfeb5f1);
• Flutter를 사용하지 말고 다른 프레임워크를 찾으세요(C#이 Dart보다 더 정교한 멀티스레딩 환경을 제공하므로 Xamarin/Blazor가 이에 적합할 수 있음).

위의 모든 것에는 단점이 있지만 실제로 설계되지 않은 작업을 수행하기 위해 라이브러리/프레임워크를 확장하는 것도 이상적이지 않습니다.

isolate_handler 가 이 문제를 해결하지 않았습니까?

@hasonguo 백그라운드에서 flutter_isolate 를 사용합니다. 통신용 상용구를 추가하여 분리(실제로 모든 분리)를 더 쉽게 처리할 수 있도록 추가 레이어를 추가하므로 매번 수동으로 설정할 필요가 없습니다. 시각. 이전에 문제를 해결하는 다른 방법을 사용했지만 Flutter 자체의 변경으로 인해 불가능해졌으며 대신 flutter_isolate 에 의존하도록 변경되었습니다.

우리는 원을 그리며 가고 있습니다. 예, 실제로 두 플러그인 모두 솔루션이 있습니다. Ryan이 지적했듯이 채널 통신을 가능하게 하는 데 수반되는 오버헤드가 있습니다. 대부분의 경우(대부분의) 지원이 필요하지 않기 때문에 Flutter 팀이 원래 Isolate 에 자동으로 추가하는 것을 피하게 만든 것은 바로 이 오버헤드입니다.

그러나 얻을 수 있는 것만큼 깨끗한 솔루션은 아닙니다. Flutter 팀이 기본 Isolate 있으면 바로 자동으로 오버헤드 없이 채널 커뮤니케이션을 제공할 수 있다면 전체 토론이 무의미해질 것입니다. 그러나 그 반대도 마찬가지입니다. 그들은 실제로 변화를 위한 변화를 추구하지 않습니다. 패키지나 플러그인에 실행 가능한 솔루션이 있다면 왜 시간을 들여 코어에 무게를 더할까요?

동일한 FlutterEngine 내에서 분리하지만 각각에 대해 새 플러그인 레지스트리 등을 생성합니다.

이것은 좋은 옵션이 될 수 있지만 엔진이 항상 자체적으로 플러그인을 등록하는 경우에만 가능합니다.

그러나 이것은 GeneratedPluginRegistrant의 모든 플러그인이 있는 경우에만 발생합니다.
https://github.com/flutter/engine/blob/f7d241fd8a889fadf8ab3f9d57918be3d986b4be/shell/platform/android/io/flutter/embedding/engine/FlutterEngine.java#L330 -L344

추가 콜백을 만드는 것은 명백한 동작이 아닙니다.

이 두 번째 아이디어에 대한 또 다른 개선 사항은 플러그인을 새 격리에서 느리게 로드하도록 하는 것입니다. 일반적으로 프로젝트가 많은 플러그인에 의존하는 경우 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 에 있습니다.
이 문제는 _ 버그 _가 아니라 _기능 요청_ 또는 _ 제안 _으로 간주 되어야 합니다.

@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>':.)

당신이 옳습니다 내 것은 좋은 예가 아니므로 무시하십시오