Flutter engine group

android/build.gradle

@@ -2,7 +2,7 @@ group 'yukams.app.background_locator_2'
 version '1.0-SNAPSHOT'
 
 buildscript {
-    ext.kotlin_version = '1.4.21'
+    ext.kotlin_version = '1.5.20'
     repositories {
         google()
         jcenter()
@@ -25,7 +25,8 @@ apply plugin: 'com.android.library'
 apply plugin: 'kotlin-android'
 
 android {
-    compileSdkVersion 29
+    namespace 'yukams.app.background_locator_2'
+    compileSdkVersion 31
 
     sourceSets {
         main.java.srcDirs += 'src/main/kotlin'

android/src/main/kotlin/yukams/app/background_locator_2/IsolateHolderExtension.kt

@@ -9,6 +9,8 @@ import android.util.Log
 import com.google.android.gms.location.LocationRequest
 import io.flutter.FlutterInjector
 import io.flutter.embedding.engine.FlutterEngine
+import io.flutter.embedding.engine.FlutterEngineGroup
+import io.flutter.embedding.engine.FlutterEngineGroupCache
 import io.flutter.embedding.engine.dart.DartExecutor
 import io.flutter.plugin.common.MethodChannel
 import io.flutter.view.FlutterCallbackInformation
@@ -34,7 +36,6 @@ internal fun IsolateHolderService.startLocatorService(context: Context) {
                 // We need flutter engine to handle callback, so if it is not available we have to create a
                 // Flutter engine without any view
                 Log.e("IsolateHolderService", "startLocatorService: Start Flutter Engine")
-                IsolateHolderService.backgroundEngine = FlutterEngine(context)
 
                 val callbackHandle = context.getSharedPreferences(
                     Keys.SHARED_PREFERENCES_KEY,
@@ -49,12 +50,28 @@ internal fun IsolateHolderService.startLocatorService(context: Context) {
                     return;
                 }
 
-                val args = DartExecutor.DartCallback(
-                    context.assets,
+                val dartEntrypoint = DartExecutor.DartEntrypoint(
                     FlutterInjector.instance().flutterLoader().findAppBundlePath(),
-                    callbackInfo
+                    "package:background_locator_2/background_locator.dart",
+                    "entrypoint"
                 )
-                IsolateHolderService.backgroundEngine?.dartExecutor?.executeDartCallback(args)
+                val args = mutableListOf<String>()
+                args.add(callbackHandle.toString())
+                val engineGroupCache = FlutterEngineGroupCache.getInstance()
+                if (engineGroupCache.contains("main")) {
+                    engineGroupCache.remove("main")
+                }
+                val engineGroup = engineGroupCache.get("main") ?: run {
+                    val newEngineGroup = FlutterEngineGroup(this)
+                    engineGroupCache.put("main", newEngineGroup)
+                    newEngineGroup
+                }
+                IsolateHolderService.backgroundEngine = engineGroup.createAndRunEngine(
+                    FlutterEngineGroup.Options(this)
+                        .setDartEntrypoint(dartEntrypoint)
+                        .setDartEntrypointArgs(args)
+                )
+
                 isServiceInitialized = true
                 Log.e("IsolateHolderExtension", "service initialized")
             }

ios/Classes/BackgroundLocatorPlugin.m

@@ -1,4 +1,5 @@
 #import "BackgroundLocatorPlugin.h"
+#import "SwizzledFlutterEngineGroupCache.h"
 #import "Globals.h"
 #import "Utils/Util.h"
 #import "Preferences/PreferencesManager.h"
@@ -12,6 +13,7 @@ @implementation BackgroundLocatorPlugin {
     NSObject<FlutterPluginRegistrar> *_registrar;
     CLLocationManager *_locationManager;
     CLLocation* _lastLocation;
+    id _backgroundActivitySession; // CLBackgroundActivitySession (iOS 17+)
 }
 
 static FlutterPluginRegistrantCallback registerPlugins = nil;
@@ -80,6 +82,12 @@ - (void)applicationDidEnterBackground:(UIApplication *)application {
 
 -(void)applicationWillTerminate:(UIApplication *)application {
     [self observeRegionForLocation:_lastLocation];
+    if (@available(iOS 17.0, *)) {
+        if (_backgroundActivitySession != nil) {
+            [(CLBackgroundActivitySession *)_backgroundActivitySession invalidate];
+            _backgroundActivitySession = nil;
+        }
+    }
     if([PreferencesManager isStopWithTerminate]){
         [self removeLocator];
     }
@@ -136,25 +144,24 @@ - (void) sendLocationEvent: (NSDictionary<NSString*,NSNumber*>*)location {
 
 - (instancetype)init:(NSObject<FlutterPluginRegistrar> *)registrar {
     self = [super init];
-    
-    _headlessRunner = [[FlutterEngine alloc] initWithName:@"LocatorIsolate" project:nil allowHeadlessExecution:YES];
+
+    _headlessRunner = nil;
     _registrar = registrar;
     [self prepareLocationManager];
-    
+
     _mainChannel = [FlutterMethodChannel methodChannelWithName:kChannelId
                                                binaryMessenger:[registrar messenger]];
     [registrar addMethodCallDelegate:self channel:_mainChannel];
-
-    _callbackChannel =
-    [FlutterMethodChannel methodChannelWithName:kBackgroundChannelId
-                                binaryMessenger:[_headlessRunner binaryMessenger] ];
     return self;
 }
 
 - (void) prepareLocationManager {
     _locationManager = [[CLLocationManager alloc] init];
     [_locationManager setDelegate:self];
     _locationManager.pausesLocationUpdatesAutomatically = NO;
+    if (@available(iOS 12.0, *)) {
+        _locationManager.activityType = CLActivityTypeAirborne;
+    }
 }
 
 #pragma mark MethodCallHelperDelegate
@@ -163,10 +170,33 @@ - (void)startLocatorService:(int64_t)handle {
     [PreferencesManager setCallbackDispatcherHandle:handle];
     FlutterCallbackInformation *info = [FlutterCallbackCache lookupCallbackInformation:handle];
     NSAssert(info != nil, @"failed to find callback");
-    
+
     NSString *entrypoint = info.callbackName;
     NSString *uri = info.callbackLibraryPath;
-    [_headlessRunner runWithEntrypoint:entrypoint libraryURI:uri];
+    NSString *groupName = @"main";
+    FlutterEngineGroup *engineGroup = nil;
+    SwizzledFlutterEngineGroupCache *engineGroupCache = [SwizzledFlutterEngineGroupCache sharedInstance];
+    if (engineGroupCache) {
+        engineGroup = [engineGroupCache get:groupName];
+    }
+    if (!engineGroup) {
+        FlutterEngineGroup *newEngineGroup = [[FlutterEngineGroup alloc] initWithName:groupName project:nil];
+        [engineGroupCache put:groupName engineGroup:newEngineGroup];
+        engineGroup = newEngineGroup;
+    }
+    if (_headlessRunner == nil) {
+        NSString *handleString = [NSString stringWithFormat:@"%lld", handle];
+        NSArray *args = @[handleString];
+        FlutterEngineGroupOptions* options = [[FlutterEngineGroupOptions alloc] init];
+        options.entrypoint = entrypoint;
+        options.libraryURI = uri;
+        options.initialRoute = nil;
+        options.entrypointArgs = args;
+        _headlessRunner = [engineGroup makeEngineWithOptions:options];
+    }
+    _callbackChannel =
+    [FlutterMethodChannel methodChannelWithName:kBackgroundChannelId
+                                binaryMessenger:[_headlessRunner binaryMessenger] ];
     NSAssert(registerPlugins != nil, @"failed to set registerPlugins");
 
     // Once our headless runner has been started, we need to register the application's plugins
@@ -216,8 +246,14 @@ - (void)registerLocator:(int64_t)callback
     DisposePluggable *disposePluggable = [[DisposePluggable alloc] init];
     [disposePluggable setCallback:disposeCallback];
 
+    if (@available(iOS 17.0, *)) {
+        if (_backgroundActivitySession == nil) {
+            _backgroundActivitySession = [CLBackgroundActivitySession backgroundActivitySession];
+            NSLog(@"BackgroundLocator: started CLBackgroundActivitySession");
+        }
+    }
+
     [_locationManager startUpdatingLocation];
-    [_locationManager startMonitoringSignificantLocationChanges];
 }
 
 - (void)removeLocator {
@@ -232,12 +268,18 @@ - (void)removeLocator {
             _locationManager.allowsBackgroundLocationUpdates = NO;
         }
 
-        [_locationManager stopMonitoringSignificantLocationChanges];
-
         for (CLRegion* region in [_locationManager monitoredRegions]) {
             [_locationManager stopMonitoringForRegion:region];
         }
     }
+
+    if (@available(iOS 17.0, *)) {
+        if (_backgroundActivitySession != nil) {
+            [(CLBackgroundActivitySession *)_backgroundActivitySession invalidate];
+            _backgroundActivitySession = nil;
+            NSLog(@"BackgroundLocator: invalidated CLBackgroundActivitySession");
+        }
+    }
 
     DisposePluggable *disposePluggable = [[DisposePluggable alloc] init];
     [disposePluggable onServiceDispose];

ios/Classes/SwizzledFlutterEngineGroupCache.h

@@ -0,0 +1,11 @@
+#import <Foundation/Foundation.h>
+#import <Flutter/Flutter.h>
+#import <Flutter/FlutterEngineGroup.h>
+
+@interface SwizzledFlutterEngineGroupCache : NSObject
+
++ (instancetype)sharedInstance;
+- (FlutterEngineGroup *)get:(NSString *)key;
+- (void)put:(NSString *)key engineGroup:(FlutterEngineGroup *)engineGroup;
+
+@end

ios/Classes/SwizzledFlutterEngineGroupCache.m

@@ -0,0 +1,31 @@
+#import "SwizzledFlutterEngineGroupCache.h"
+#import <objc/runtime.h>
+
+@implementation SwizzledFlutterEngineGroupCache
+
++ (instancetype)sharedInstance {
+    // Retrieve the original class by name using reflection
+    Class originalClass = NSClassFromString(@"SwizzlableFlutterEngineGroupCache");
+
+    // Check if the class exists
+    if (originalClass && [originalClass respondsToSelector:@selector(sharedInstance)]) {
+        // Call the original sharedInstance method dynamically
+        id sharedInstance = [originalClass performSelector:@selector(sharedInstance)];
+        return sharedInstance;
+    }
+
+    // Return nil or handle failure if the class or method is not found
+    NSLog(@"Original class or sharedInstance method not found");
+    return nil;
+}
+
+- (FlutterEngineGroup *)get:(NSString *)key {
+    // Interface
+    return nil;
+}
+
+- (void)put:(NSString *)key engineGroup:(FlutterEngineGroup *)engineGroup {
+    // Interface
+}
+
+@end

lib/background_locator.dart

@@ -12,6 +12,17 @@ import 'callback_dispatcher.dart';
 import 'keys.dart';
 import 'location_dto.dart';
 
+@pragma('vm:entry-point')
+Future<void> entrypoint(List<String> args) async {
+  WidgetsFlutterBinding.ensureInitialized();
+  final int handle = int.parse(args.first);
+  final callbackHandle = CallbackHandle.fromRawHandle(handle);
+  final callback = PluginUtilities.getCallbackFromHandle(callbackHandle);
+  if (callback != null) {
+    callback();
+  }
+}
+
 class BackgroundLocator {
   static const MethodChannel _channel = const MethodChannel(Keys.CHANNEL_ID);