Flutter应用生命周期变化时如何全局停止所有音视频流？

针对你集成video_player、just_audio、audioplayers多个播放器，需要在应用生命周期变化时全局管控媒体流的需求，以下是几种高效的实现方式：

一、Flutter层封装全局播放器管理器（推荐） #

通过单例管理器统一注册、管控所有播放器实例，避免手动逐个维护，代码简洁且可控。

1. 实现全局管理器 #

创建一个单例类，维护所有活跃播放器实例，并提供统一的暂停/停止方法：

import 'package:video_player/video_player.dart';
import 'package:just_audio/just_audio.dart' as ja;
import 'package:audioplayers/audioplayers.dart' as ap;

class MediaPlayerManager {
  // 单例实例
  static final MediaPlayerManager instance = MediaPlayerManager._internal();
  MediaPlayerManager._internal();

  // 存储所有注册的播放器
  final List<dynamic> _activePlayers = [];

  // 注册播放器
  void registerPlayer(dynamic player) {
    if (!_activePlayers.contains(player)) {
      _activePlayers.add(player);
    }
  }

  // 注销播放器（避免内存泄漏）
  void unregisterPlayer(dynamic player) {
    _activePlayers.remove(player);
  }

  // 全局暂停所有媒体
  void pauseAll() {
    for (final player in _activePlayers) {
      if (player is VideoPlayerController) {
        if (player.value.isPlaying) player.pause();
      } else if (player is ja.AudioPlayer) {
        if (player.playing) player.pause();
      } else if (player is ap.AudioPlayer) {
        player.pause();
      }
    }
  }

  // 全局停止所有媒体
  void stopAll() {
    for (final player in _activePlayers) {
      if (player is VideoPlayerController) {
        player.pause();
        player.seek(const Duration(seconds: 0));
      } else if (player is ja.AudioPlayer) {
        player.stop();
      } else if (player is ap.AudioPlayer) {
        player.stop();
      }
    }
  }
}

2. 注册与注销播放器 #

在创建播放器的页面中，完成注册与注销：

class VideoPage extends StatefulWidget {
  @override
  State<VideoPage> createState() => _VideoPageState();
}

class _VideoPageState extends State<VideoPage> {
  late VideoPlayerController _videoController;

  @override
  void initState() {
    super.initState();
    _videoController = VideoPlayerController.network('视频URL');
    // 注册到全局管理器
    MediaPlayerManager.instance.registerPlayer(_videoController);
  }

  @override
  void dispose() {
    // 注销播放器
    MediaPlayerManager.instance.unregisterPlayer(_videoController);
    _videoController.dispose();
    super.dispose();
  }

  // 页面其他代码...
}

3. 结合生命周期触发全局管控 #

在根Widget的生命周期回调中，根据应用状态调用全局方法：

class MyApp extends StatefulWidget {
  @override
  State<MyApp> createState() => _MyAppState();
}

class _MyAppState extends State<MyApp> with WidgetsBindingObserver {
  @override
  void initState() {
    super.initState();
    WidgetsBinding.instance.addObserver(this);
  }

  @override
  void didChangeAppLifecycleState(AppLifecycleState state) {
    super.didChangeAppLifecycleState(state);
    switch (state) {
      case AppLifecycleState.paused:
        // 应用进入后台，暂停所有媒体
        MediaPlayerManager.instance.pauseAll();
        break;
      case AppLifecycleState.resumed:
        // 应用回到前台，可选恢复播放（根据业务需求）
        break;
      case AppLifecycleState.inactive:
      case AppLifecycleState.detached:
        // 应用脱离活跃状态，停止所有媒体
        MediaPlayerManager.instance.stopAll();
        break;
    }
  }

  @override
  void dispose() {
    WidgetsBinding.instance.removeObserver(this);
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return MaterialApp(/* ... */);
  }
}

二、平台原生全局控制方案 #

如果完全不想维护播放器实例，可以通过原生API实现全局媒体管控，但需注意可能会影响系统内其他APP的媒体播放。

Android端实现 #

通过AudioManager请求音频焦点，自动暂停所有正在播放的媒体：

1. 原生Kotlin代码（MainActivity）：

import android.media.AudioAttributes
import android.media.AudioFocusRequest
import android.media.AudioManager
import io.flutter.embedding.android.FlutterActivity
import io.flutter.embedding.engine.FlutterEngine
import io.flutter.plugin.common.MethodChannel

class MainActivity : FlutterActivity() {
    private val CHANNEL = "your.app.package/media_control"

    override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
        super.configureFlutterEngine(flutterEngine)
        MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CHANNEL).setMethodCallHandler { call, result ->
            if (call.method == "pauseAllMedia") {
                val audioManager = getSystemService(AUDIO_SERVICE) as AudioManager
                val focusRequest = AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN_TRANSIENT)
                    .setAudioAttributes(AudioAttributes.Builder()
                        .setUsage(AudioAttributes.USAGE_MEDIA)
                        .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
                        .build())
                    .setOnAudioFocusChangeListener { }
                    .build()
                val focusResult = audioManager.requestAudioFocus(focusRequest)
                result.success(focusResult == AudioManager.AUDIOFOCUS_REQUEST_GRANTED)
            } else {
                result.notImplemented()
            }
        }
    }
}

2. Flutter端调用：

import 'package:flutter/services.dart';

class MediaControl {
  static const _channel = MethodChannel('your.app.package/media_control');

  static Future<bool> pauseAllMedia() async {
    try {
      return await _channel.invokeMethod('pauseAllMedia');
    } on PlatformException catch (e) {
      print("暂停失败: ${e.message}");
      return false;
    }
  }
}

iOS端实现 #

通过AVAudioSession管控媒体播放，或发送通知让内部播放器暂停：

1. 原生Swift代码（AppDelegate）：

import UIKit
import Flutter
import AVFoundation

class AppDelegate: FlutterAppDelegate {
    private let CHANNEL = "your.app.package/media_control"

    override func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        let controller = window?.rootViewController as! FlutterViewController
        let channel = FlutterMethodChannel(name: CHANNEL, binaryMessenger: controller.binaryMessenger)
        channel.setMethodCallHandler { [weak self] call, result in
            guard call.method == "pauseAllMedia" else {
                result(FlutterMethodNotImplemented)
                return
            }
            let audioSession = AVAudioSession.sharedInstance()
            do {
                // 停用音频会话，触发所有媒体暂停
                try audioSession.setActive(false, options: .notifyOthersOnDeactivation)
                result(true)
            } catch {
                result(FlutterError(code: "ERROR", message: error.localizedDescription, details: nil))
            }
        }
        GeneratedPluginRegistrant.register(with: self)
        return super.application(application, didFinishLaunchingWithOptions: launchOptions)
    }
}

2. Flutter端调用同Android的MediaControl类。

方案对比 #

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