Flutter中如何检测用户强制杀死应用？现有方案失效求解决

问题背景 #

尝试通过WidgetsBindingObserver监听应用生命周期来检测用户强制退出应用，但该方案在用户强制杀死应用进程时无法触发回调，需要支持异步操作的可行回调方案。

参考的原有实现代码：

WidgetsBinding.instance.addObserver(LifecycleEventHandler(
        detachedCallBack: () async => widget.appController.persistState(),
        resumeCallBack: () async {
          _log.finest('resume...');
        }));

class LifecycleEventHandler extends WidgetsBindingObserver {
  LifecycleEventHandler({this.resumeCallBack, this.detachedCallBack});

  final FutureVoidCallback resumeCallBack;
  final FutureVoidCallback detachedCallBack;

  @override
  Future<void> didChangeAppLifecycleState(AppLifecycleState state) async {
    switch (state) {
      case AppLifecycleState.inactive:
      case AppLifecycleState.paused:
      case AppLifecycleState.detached:
        await detachedCallBack();
        break;
      case AppLifecycleState.resumed:
        await resumeCallBack();
        break;
    }
    _log.finest('''
=============================================================
               $state
=============================================================
''');
  }
}

可行解决方案 #

1. 平台原生监听（最可靠） #

Flutter自身的生命周期监听无法覆盖强制杀进程场景，必须依赖原生平台的专属回调：

Android 端实现

在MainActivity中重写onTaskRemoved方法，通过MethodChannel通知Flutter执行异步操作：

class MainActivity : FlutterActivity() {
    private val CHANNEL = "com.example.app/exit"

    override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
        super.configureFlutterEngine(flutterEngine)
        MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CHANNEL).setMethodCallHandler { call, result ->
            if (call.method == "persistState") {
                // 可直接执行原生异步操作，或通知Flutter处理
                result.success(true)
            }
        }
    }

    override fun onTaskRemoved(rootIntent: Intent?) {
        super.onTaskRemoved(rootIntent)
        flutterEngine?.let {
            val channel = MethodChannel(it.dartExecutor.binaryMessenger, CHANNEL)
            channel.invokeMethod("persistState", null)
            // 预留短暂时间完成异步操作后再结束进程
            Handler(Looper.getMainLooper()).postDelayed({
                finishAndRemoveTask()
                System.exit(0)
            }, 1000)
        }
    }
}

iOS 端实现

在AppDelegate中重写applicationWillTerminate方法：

#import "AppDelegate.h"
#import "GeneratedPluginRegistrant.h"

@implementation AppDelegate

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
  GeneratedPluginRegistrantRegisterWithRegistry(self);
  FlutterViewController* controller = (FlutterViewController*)self.window.rootViewController;
  FlutterMethodChannel* channel = [FlutterMethodChannel methodChannelWithName:@"com.example.app/exit"
                                                          binaryMessenger:controller.binaryMessenger];
  [channel setMethodCallHandler:^(FlutterMethodCall* call, FlutterResult result) {
    if ([@"persistState" isEqualToString:call.method]) {
      // 执行异步持久化操作
      result(@YES);
    } else {
      result(FlutterMethodNotImplemented);
    }
  }];
  return [super application:application didFinishLaunchingWithOptions:launchOptions];
}

- (void)applicationWillTerminate:(UIApplication *)application {
  FlutterViewController* controller = (FlutterViewController*)self.window.rootViewController;
  FlutterMethodChannel* channel = [FlutterMethodChannel methodChannelWithName:@"com.example.app/exit"
                                                          binaryMessenger:controller.binaryMessenger];
  [channel invokeMethod:@"persistState" arguments:nil];
}

@end

Flutter 端接收回调

class _MyAppState extends State<MyApp> {
  static const platform = MethodChannel('com.example.app/exit');

  @override
  void initState() {
    super.initState();
    platform.setMethodCallHandler((call) async {
      if (call.method == 'persistState') {
        await widget.appController.persistState();
        return true;
      }
      return null;
    });
  }
}

2. 使用Isolate做后台异步监听 #

创建独立的Isolate监听应用状态，即使主Isolate被杀死，后台Isolate可能获得短暂执行时间：

void _startBackgroundIsolate() async {
  final receivePort = ReceivePort();
  await Isolate.spawn(_backgroundListener, receivePort.sendPort);

  final sendPort = await receivePort.first as SendPort;
  sendPort.send('init');
}

void _backgroundListener(SendPort sendPort) async {
  final receivePort = ReceivePort();
  sendPort.send(receivePort.sendPort);

  await for (final message in receivePort) {
    if (message == 'appExit') {
      // 执行异步持久化操作
      await AppController().persistState();
    }
  }
}

// 在主Isolate的生命周期回调中通知后台Isolate
@override
void didChangeAppLifecycleState(AppLifecycleState state) {
  if (state == AppLifecycleState.detached) {
    _sendMessageToIsolate('appExit');
  }
}

3. 实时状态持久化（兜底方案） #

放弃依赖退出回调，改为在状态变更时实时保存，避免依赖退出时的一次性操作：

// 示例：状态变更时立即触发异步保存
void updateUserState(UserState newState) {
  setState(() {
    _userState = newState;
  });
  // 异步持久化最新状态
  widget.appController.persistState(newState);
}

注意事项 #

• 强制杀进程时系统留给应用的执行时间极短，异步操作要尽量轻量化，避免耗时任务
• Android的onTaskRemoved在应用被从最近任务列表移除时触发；iOS的applicationWillTerminate在应用被系统/用户主动终止时触发，但后台挂起时可能延迟触发
• Isolate方案的可靠性依赖系统调度，无法保证100%执行

内容的提问来源于stack exchange，提问作者kokoko