630 lines
22 KiB
Swift
630 lines
22 KiB
Swift
import Flutter
|
|
import UIKit
|
|
import AVFoundation
|
|
import AVKit
|
|
|
|
private let thumbnailHTTPHeaderFieldsKey = "AVURLAssetHTTPHeaderFieldsKey"
|
|
|
|
private final class ThumbnailResponseGate {
|
|
private let lock = NSLock()
|
|
private var completed = false
|
|
|
|
func send(_ result: @escaping FlutterResult, data: Data?) {
|
|
lock.lock()
|
|
if completed {
|
|
lock.unlock()
|
|
return
|
|
}
|
|
completed = true
|
|
lock.unlock()
|
|
DispatchQueue.main.async {
|
|
result(data)
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Keeps the system LaunchScreen as the only splash. Flutter would otherwise
|
|
/// instantiate that storyboard again and the icon appears a second time.
|
|
final class RunnerFlutterViewController: FlutterViewController {
|
|
override func loadDefaultSplashScreenView() -> Bool {
|
|
false
|
|
}
|
|
|
|
override func viewDidLoad() {
|
|
super.viewDidLoad()
|
|
view.backgroundColor = .black
|
|
}
|
|
}
|
|
|
|
/// iOS 影子播放器：独立 AVPlayer + AVPlayerLayer 专供画中画窗口。
|
|
/// Flutter 的 video_player 走纹理渲染，没有 AVPlayerLayer，无法直接创建
|
|
/// AVPictureInPictureController；小窗的画面与声音由影子接管，退出时把
|
|
/// 影子进度回传给 Dart，由 Flutter 播放器 seek 对齐后继续。
|
|
final class PipShadowCoordinator: NSObject, AVPictureInPictureControllerDelegate {
|
|
static let shared = PipShadowCoordinator()
|
|
|
|
private var player: AVPlayer?
|
|
private var playerLayer: AVPlayerLayer?
|
|
private var controller: AVPictureInPictureController?
|
|
private var endObserver: NSObjectProtocol?
|
|
private var possibleObservation: NSKeyValueObservation?
|
|
/// 画中画还原过渡层：原生窗口级红晕渐变，在系统还原动画开始时立即盖上，
|
|
/// 避免回前台瞬间 Flutter 表面未恢复显示黑帧；视频出帧后由 Dart 通知淡出。
|
|
private var restoreOverlay: UIView?
|
|
/// 系统要求 playerLayer 位于真实的 view 层级中才会判定画中画可用，
|
|
/// 因此用 1x1 透明宿主 view 承载，而不是直接挂在 window.layer 上。
|
|
private var hostView: UIView?
|
|
/// 影子图层就绪稍晚于创建，置位后由 KVO 自动拉起画中画。
|
|
private var pendingStart = false
|
|
private var startRetryWorkItems: [DispatchWorkItem] = []
|
|
|
|
weak var channel: FlutterMethodChannel?
|
|
|
|
/// active 变化回调；停止时把影子最终进度（毫秒）一并提供。
|
|
var onPipChanged: ((Bool, Int64) -> Void)?
|
|
/// 影子在画中画里播完当前集。
|
|
var onPlaybackEnded: (() -> Void)?
|
|
|
|
static var isSupported: Bool {
|
|
AVPictureInPictureController.isPictureInPictureSupported()
|
|
}
|
|
|
|
private var keyWindow: UIWindow? {
|
|
UIApplication.shared.connectedScenes
|
|
.compactMap { $0 as? UIWindowScene }
|
|
.flatMap { $0.windows }
|
|
.first { $0.isKeyWindow }
|
|
}
|
|
|
|
/// 首次创建影子：1x1 图层挂在 keyWindow 的宿主 view 里（肉眼不可见），静音待命。
|
|
/// [autoEnter] 为 true 时退后台由系统自动拉起画中画（需影子在播，见 armAutoEnter）。
|
|
func prepare(urlString: String, positionMs: Int64, autoEnter: Bool) {
|
|
teardown()
|
|
log("prepare begin supported=\(PipShadowCoordinator.isSupported) autoEnter=\(autoEnter)")
|
|
guard Self.isSupported else { return }
|
|
guard let url = URL(string: urlString) else {
|
|
log("prepare failed bad url \(urlString)")
|
|
return
|
|
}
|
|
guard let window = keyWindow else {
|
|
log("prepare failed no key window")
|
|
return
|
|
}
|
|
let item = AVPlayerItem(url: url)
|
|
let p = AVPlayer(playerItem: item)
|
|
p.isMuted = true
|
|
p.actionAtItemEnd = .pause
|
|
let layer = AVPlayerLayer()
|
|
layer.player = p
|
|
let host = UIView(frame: CGRect(x: 0, y: 0, width: 1, height: 1))
|
|
host.isUserInteractionEnabled = false
|
|
host.backgroundColor = .clear
|
|
window.addSubview(host)
|
|
layer.frame = host.bounds
|
|
host.layer.addSublayer(layer)
|
|
hostView = host
|
|
guard let c = AVPictureInPictureController(playerLayer: layer) else {
|
|
p.pause()
|
|
log("prepare failed no pip controller")
|
|
return
|
|
}
|
|
c.canStartPictureInPictureAutomaticallyFromInline = autoEnter
|
|
c.delegate = self
|
|
player = p
|
|
playerLayer = layer
|
|
controller = c
|
|
// 静音起播让 item 完成首帧解码，isPictureInPicturePossible 才会变 true。
|
|
p.play()
|
|
possibleObservation = c.observe(
|
|
\.isPictureInPicturePossible,
|
|
options: [.new, .initial]
|
|
) { [weak self] controller, change in
|
|
let value = change.newValue ?? controller.isPictureInPicturePossible
|
|
self?.log("possible changed to \(value)")
|
|
guard let self, self.pendingStart, controller.isPictureInPicturePossible else { return }
|
|
self.pendingStart = false
|
|
// 刚翻 true 的同一 runloop 里调用会被系统静默拒绝，推到下一拍再进。
|
|
DispatchQueue.main.async {
|
|
guard self.controller === controller, controller.isPictureInPicturePossible else {
|
|
self.log("start via kvo aborted (shadow replaced)")
|
|
return
|
|
}
|
|
self.log("start via kvo")
|
|
controller.startPictureInPicture()
|
|
}
|
|
}
|
|
log("shadow ready, seeking to \(positionMs)ms")
|
|
if positionMs > 0 {
|
|
p.seek(
|
|
to: CMTime(value: positionMs, timescale: 1000),
|
|
toleranceBefore: .zero,
|
|
toleranceAfter: .zero
|
|
)
|
|
}
|
|
registerEndObserver(for: item)
|
|
activateAudioSession()
|
|
}
|
|
|
|
/// 退出 App 前（inactive）把影子对齐到当前进度并静音起播：
|
|
/// auto PiP 只在「player 正在播放 + 图层离屏」时由系统触发。
|
|
func armAutoEnter(positionMs: Int64) {
|
|
guard let player, let controller else {
|
|
log("arm failed, shadow missing")
|
|
return
|
|
}
|
|
guard controller.canStartPictureInPictureAutomaticallyFromInline else {
|
|
log("arm failed, autoEnter disabled on shadow")
|
|
return
|
|
}
|
|
log("arm auto enter at \(positionMs)ms")
|
|
if positionMs > 0 {
|
|
player.seek(
|
|
to: CMTime(value: positionMs, timescale: 1000),
|
|
toleranceBefore: CMTime(value: 800, timescale: 1000),
|
|
toleranceAfter: CMTime(value: 800, timescale: 1000)
|
|
)
|
|
}
|
|
player.play()
|
|
}
|
|
|
|
/// 回前台后取消待命：影子暂停回静音，等待下一次退后台。
|
|
func disarmAutoEnter() {
|
|
guard let player else { return }
|
|
log("disarm auto enter")
|
|
player.pause()
|
|
player.isMuted = true
|
|
}
|
|
|
|
/// 进入画中画：图层就绪则立即进入，否则 KVO/延时重试在就绪后自动进入。
|
|
/// 仅当影子从未创建成功（prepare 失败）时返回 false。
|
|
func start() -> Bool {
|
|
guard let controller else {
|
|
log("start failed, shadow not created")
|
|
return false
|
|
}
|
|
log("start requested possible=\(controller.isPictureInPicturePossible)")
|
|
pendingStart = true
|
|
if controller.isPictureInPicturePossible {
|
|
pendingStart = false
|
|
controller.startPictureInPicture()
|
|
}
|
|
scheduleStartRetries()
|
|
return true
|
|
}
|
|
|
|
/// KVO 偶发不触发或流加载较慢时兜底：就绪后再试两次。
|
|
private func scheduleStartRetries() {
|
|
startRetryWorkItems.forEach { $0.cancel() }
|
|
startRetryWorkItems.removeAll()
|
|
for delay in [1.0, 2.5] {
|
|
let item = DispatchWorkItem { [weak self] in
|
|
guard
|
|
let self,
|
|
self.pendingStart,
|
|
let controller = self.controller,
|
|
controller.isPictureInPicturePossible
|
|
else { return }
|
|
self.log("start via retry after \(delay)s")
|
|
self.pendingStart = false
|
|
controller.startPictureInPicture()
|
|
}
|
|
startRetryWorkItems.append(item)
|
|
DispatchQueue.main.asyncAfter(deadline: .now() + delay, execute: item)
|
|
}
|
|
}
|
|
|
|
/// 画中画内换集：只换 AVPlayerItem，不动 player/layer，窗口不中断。
|
|
func replaceItem(urlString: String, positionMs: Int64) {
|
|
guard let player, let url = URL(string: urlString) else { return }
|
|
let item = AVPlayerItem(url: url)
|
|
player.replaceCurrentItem(with: item)
|
|
registerEndObserver(for: item)
|
|
if positionMs > 0 {
|
|
player.seek(
|
|
to: CMTime(value: positionMs, timescale: 1000),
|
|
toleranceBefore: .zero,
|
|
toleranceAfter: .zero
|
|
)
|
|
}
|
|
}
|
|
|
|
/// 进入画中画后解除静音并起播（此时 Flutter 播放器已被暂停）。
|
|
func unmuteAndPlay() {
|
|
player?.isMuted = false
|
|
player?.play()
|
|
}
|
|
|
|
func positionMs() -> Int64 {
|
|
Int64(max(0, player?.currentTime().seconds ?? 0) * 1000)
|
|
}
|
|
|
|
func stopPip() {
|
|
controller?.stopPictureInPicture()
|
|
}
|
|
|
|
func teardown() {
|
|
startRetryWorkItems.forEach { $0.cancel() }
|
|
startRetryWorkItems.removeAll()
|
|
possibleObservation?.invalidate()
|
|
possibleObservation = nil
|
|
pendingStart = false
|
|
if let endObserver {
|
|
NotificationCenter.default.removeObserver(endObserver)
|
|
}
|
|
endObserver = nil
|
|
player?.pause()
|
|
player?.replaceCurrentItem(with: nil)
|
|
playerLayer?.removeFromSuperlayer()
|
|
playerLayer = nil
|
|
hostView?.removeFromSuperview()
|
|
hostView = nil
|
|
controller?.delegate = nil
|
|
controller = nil
|
|
player = nil
|
|
}
|
|
|
|
/// 诊断日志：NSLog 之外同步转发到 Dart，便于在 flutter run 控制台观察。
|
|
private func log(_ message: String) {
|
|
NSLog("pip: %@", message)
|
|
channel?.invokeMethod("pipDebug", arguments: message)
|
|
}
|
|
|
|
private func registerEndObserver(for item: AVPlayerItem) {
|
|
if let endObserver {
|
|
NotificationCenter.default.removeObserver(endObserver)
|
|
}
|
|
endObserver = NotificationCenter.default.addObserver(
|
|
forName: .AVPlayerItemDidPlayToEndTime,
|
|
object: item,
|
|
queue: .main
|
|
) { [weak self] _ in
|
|
self?.log("item did play to end")
|
|
self?.onPlaybackEnded?()
|
|
}
|
|
}
|
|
|
|
/// 画中画的声音走影子播放器，需要 playback 类别的音频会话保活。
|
|
private func activateAudioSession() {
|
|
do {
|
|
try AVAudioSession.sharedInstance().setCategory(.playback, mode: .moviePlayback)
|
|
try AVAudioSession.sharedInstance().setActive(true)
|
|
} catch {
|
|
// 会话激活失败只影响后台出声，不阻断画中画。
|
|
}
|
|
}
|
|
|
|
func pictureInPictureControllerWillStartPictureInPicture(
|
|
_ pictureInPictureController: AVPictureInPictureController
|
|
) {
|
|
log("will start")
|
|
pendingStart = false
|
|
onPipChanged?(true, 0)
|
|
}
|
|
|
|
func pictureInPictureControllerWillStopPictureInPicture(
|
|
_ pictureInPictureController: AVPictureInPictureController
|
|
) {
|
|
log("will stop, showing restore overlay")
|
|
showRestoreOverlay()
|
|
}
|
|
|
|
func pictureInPictureControllerDidStopPictureInPicture(
|
|
_ pictureInPictureController: AVPictureInPictureController
|
|
) {
|
|
log("did stop")
|
|
showRestoreOverlay()
|
|
onPipChanged?(false, positionMs())
|
|
}
|
|
|
|
/// 盖原生过渡层（幂等）：主题红晕渐变，不依赖 Flutter 渲染。
|
|
func showRestoreOverlay() {
|
|
guard let window = keyWindow else { return }
|
|
restoreOverlay?.removeFromSuperview()
|
|
let overlay = UIView(frame: window.bounds)
|
|
overlay.autoresizingMask = [.flexibleWidth, .flexibleHeight]
|
|
let gradient = CAGradientLayer()
|
|
gradient.frame = overlay.bounds
|
|
gradient.colors = [
|
|
UIColor(red: 0.298, green: 0.086, blue: 0.102, alpha: 1).cgColor,
|
|
UIColor(red: 0.118, green: 0.043, blue: 0.047, alpha: 1).cgColor,
|
|
UIColor(red: 0.063, green: 0.063, blue: 0.071, alpha: 1).cgColor,
|
|
]
|
|
gradient.locations = [0, 0.22, 0.62]
|
|
gradient.startPoint = CGPoint(x: 0.5, y: 0)
|
|
gradient.endPoint = CGPoint(x: 0.5, y: 1)
|
|
overlay.layer.addSublayer(gradient)
|
|
window.addSubview(overlay)
|
|
restoreOverlay = overlay
|
|
}
|
|
|
|
/// 淡出并移除过渡层（视频首帧已确认后由 Dart 调用）。
|
|
func hideRestoreOverlay() {
|
|
guard let overlay = restoreOverlay else { return }
|
|
restoreOverlay = nil
|
|
UIView.animate(
|
|
withDuration: 0.25,
|
|
animations: { overlay.alpha = 0 }
|
|
) { _ in overlay.removeFromSuperview() }
|
|
}
|
|
}
|
|
|
|
@main
|
|
@objc class AppDelegate: FlutterAppDelegate, FlutterImplicitEngineDelegate {
|
|
private let wirelessDataPrompt = WirelessDataPrompt()
|
|
private let thumbnailQueue = DispatchQueue(
|
|
label: "com.stormg.lumadrama.thumbnail",
|
|
qos: .userInitiated
|
|
)
|
|
|
|
override func application(
|
|
_ application: UIApplication,
|
|
didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
|
|
) -> Bool {
|
|
UIApplication.shared.isIdleTimerDisabled = true
|
|
return super.application(application, didFinishLaunchingWithOptions: launchOptions)
|
|
}
|
|
|
|
override func applicationDidBecomeActive(_ application: UIApplication) {
|
|
super.applicationDidBecomeActive(application)
|
|
requestWirelessDataPrompt()
|
|
}
|
|
|
|
func requestWirelessDataPrompt() {
|
|
wirelessDataPrompt.requestSystemPrompt()
|
|
}
|
|
|
|
func didInitializeImplicitFlutterEngine(_ engineBridge: FlutterImplicitEngineBridge) {
|
|
GeneratedPluginRegistrant.register(with: engineBridge.pluginRegistry)
|
|
registerWirelessDataChannel(engineBridge)
|
|
registerDeviceIdChannel(engineBridge)
|
|
registerPipChannel(engineBridge)
|
|
let channel = FlutterMethodChannel(
|
|
name: "com.stormg.lumadrama/share",
|
|
binaryMessenger: engineBridge.applicationRegistrar.messenger()
|
|
)
|
|
channel.setMethodCallHandler { [weak self] call, result in
|
|
guard call.method == "shareText",
|
|
let arguments = call.arguments as? [String: Any],
|
|
let text = arguments["text"] as? String,
|
|
!text.isEmpty else {
|
|
result(FlutterError(code: "share_unavailable", message: "Share sheet is unavailable", details: nil))
|
|
return
|
|
}
|
|
DispatchQueue.main.async {
|
|
guard let controller = self?.sharePresenter() else {
|
|
result(FlutterError(code: "share_unavailable", message: "Share sheet is unavailable", details: nil))
|
|
return
|
|
}
|
|
let activity = UIActivityViewController(activityItems: [text], applicationActivities: nil)
|
|
if let popover = activity.popoverPresentationController {
|
|
popover.sourceView = controller.view
|
|
popover.sourceRect = CGRect(
|
|
x: controller.view.bounds.midX,
|
|
y: controller.view.bounds.midY,
|
|
width: 0,
|
|
height: 0
|
|
)
|
|
popover.permittedArrowDirections = []
|
|
}
|
|
activity.completionWithItemsHandler = { _, _, _, _ in result(nil) }
|
|
controller.present(activity, animated: true)
|
|
}
|
|
}
|
|
|
|
let thumbnailChannel = FlutterMethodChannel(
|
|
name: "com.stormg.lumadrama/thumbnail",
|
|
binaryMessenger: engineBridge.applicationRegistrar.messenger()
|
|
)
|
|
thumbnailChannel.setMethodCallHandler { [weak self] call, result in
|
|
guard call.method == "frame" else {
|
|
result(FlutterMethodNotImplemented)
|
|
return
|
|
}
|
|
guard let self,
|
|
let arguments = call.arguments as? [String: Any],
|
|
let timeNumber = arguments["timeMs"] as? NSNumber else {
|
|
result(nil)
|
|
return
|
|
}
|
|
let localPath = arguments["localPath"] as? String ?? ""
|
|
let remoteUrl = arguments["url"] as? String ?? ""
|
|
let headers = arguments["headers"] as? [String: String] ?? [:]
|
|
let assetUrl: URL?
|
|
if !localPath.isEmpty {
|
|
assetUrl = localPath.hasPrefix("file:")
|
|
? URL(string: localPath)
|
|
: URL(fileURLWithPath: localPath)
|
|
} else if !remoteUrl.isEmpty {
|
|
assetUrl = URL(string: remoteUrl)
|
|
} else {
|
|
assetUrl = nil
|
|
}
|
|
guard let assetUrl else {
|
|
result(nil)
|
|
return
|
|
}
|
|
|
|
let options: [String: Any]? = headers.isEmpty
|
|
? nil
|
|
: [thumbnailHTTPHeaderFieldsKey: headers]
|
|
let asset = AVURLAsset(url: assetUrl, options: options)
|
|
let generator = AVAssetImageGenerator(asset: asset)
|
|
generator.appliesPreferredTrackTransform = true
|
|
generator.maximumSize = CGSize(width: 240, height: 426)
|
|
generator.requestedTimeToleranceBefore = CMTime(seconds: 0.5, preferredTimescale: 600)
|
|
generator.requestedTimeToleranceAfter = CMTime(seconds: 0.5, preferredTimescale: 600)
|
|
let time = CMTime(value: timeNumber.int64Value, timescale: 1000)
|
|
let gate = ThumbnailResponseGate()
|
|
|
|
self.thumbnailQueue.async {
|
|
do {
|
|
let image = try generator.copyCGImage(at: time, actualTime: nil)
|
|
let data = UIImage(cgImage: image).jpegData(compressionQuality: 0.7)
|
|
gate.send(result, data: data)
|
|
} catch {
|
|
gate.send(result, data: nil)
|
|
}
|
|
}
|
|
DispatchQueue.global(qos: .userInitiated).asyncAfter(
|
|
deadline: .now() + 1.5
|
|
) {
|
|
gate.send(result, data: nil)
|
|
}
|
|
}
|
|
}
|
|
|
|
/// 当前前台 Scene 的根控制器之上，最适合展示系统分享面板的控制器。
|
|
private func sharePresenter() -> UIViewController? {
|
|
let keyWindow = UIApplication.shared.connectedScenes
|
|
.compactMap { $0 as? UIWindowScene }
|
|
.first { $0.activationState == .foregroundActive }?
|
|
.windows.first { $0.isKeyWindow }
|
|
guard let rootController = keyWindow?.rootViewController else { return nil }
|
|
let presenter = topPresentedController(from: rootController)
|
|
guard presenter.viewIfLoaded?.window != nil else { return nil }
|
|
return presenter
|
|
}
|
|
|
|
/// 解析已展示页面、导航栈和标签页中的当前可见控制器。
|
|
private func topPresentedController(from controller: UIViewController) -> UIViewController {
|
|
if let presented = controller.presentedViewController {
|
|
return topPresentedController(from: presented)
|
|
}
|
|
if let navigation = controller as? UINavigationController,
|
|
let visible = navigation.visibleViewController {
|
|
return topPresentedController(from: visible)
|
|
}
|
|
if let tabs = controller as? UITabBarController,
|
|
let selected = tabs.selectedViewController {
|
|
return topPresentedController(from: selected)
|
|
}
|
|
return controller
|
|
}
|
|
|
|
/// iOS 画中画：影子播放器通道，与 Android 共用同一 channel 名。
|
|
private func registerPipChannel(_ engineBridge: FlutterImplicitEngineBridge) {
|
|
let channel = FlutterMethodChannel(
|
|
name: "com.stormg.lumadrama/pip",
|
|
binaryMessenger: engineBridge.applicationRegistrar.messenger()
|
|
)
|
|
let pip = PipShadowCoordinator.shared
|
|
pip.channel = channel
|
|
channel.setMethodCallHandler { call, result in
|
|
switch call.method {
|
|
case "isAvailable":
|
|
result(PipShadowCoordinator.isSupported)
|
|
case "enter":
|
|
guard let args = call.arguments as? [String: Any],
|
|
let url = args["url"] as? String else {
|
|
result(false)
|
|
return
|
|
}
|
|
let positionMs = (args["positionMs"] as? NSNumber)?.int64Value ?? 0
|
|
pip.prepare(urlString: url, positionMs: positionMs, autoEnter: false)
|
|
// 等一拍让 AVPlayerLayer 完成挂载再请求进入画中画。
|
|
DispatchQueue.main.async {
|
|
result(pip.start())
|
|
}
|
|
case "prepareShadow":
|
|
guard let args = call.arguments as? [String: Any],
|
|
let url = args["url"] as? String else {
|
|
result(nil)
|
|
return
|
|
}
|
|
pip.prepare(
|
|
urlString: url,
|
|
positionMs: (args["positionMs"] as? NSNumber)?.int64Value ?? 0,
|
|
autoEnter: (args["autoEnter"] as? NSNumber)?.boolValue ?? false
|
|
)
|
|
result(nil)
|
|
case "armAutoEnter":
|
|
pip.armAutoEnter(
|
|
positionMs: (call.arguments as? [String: Any])?["positionMs"] as? Int64 ?? 0
|
|
)
|
|
result(nil)
|
|
case "showRestoreOverlay":
|
|
pip.showRestoreOverlay()
|
|
result(nil)
|
|
case "hideRestoreOverlay":
|
|
pip.hideRestoreOverlay()
|
|
result(nil)
|
|
case "disarmAutoEnter":
|
|
pip.disarmAutoEnter()
|
|
result(nil)
|
|
case "unmute":
|
|
pip.unmuteAndPlay()
|
|
result(nil)
|
|
case "replaceItem":
|
|
guard let args = call.arguments as? [String: Any],
|
|
let url = args["url"] as? String else {
|
|
result(nil)
|
|
return
|
|
}
|
|
pip.replaceItem(
|
|
urlString: url,
|
|
positionMs: (args["positionMs"] as? NSNumber)?.int64Value ?? 0
|
|
)
|
|
result(nil)
|
|
case "stop":
|
|
pip.stopPip()
|
|
result(nil)
|
|
case "teardown":
|
|
pip.teardown()
|
|
result(nil)
|
|
default:
|
|
result(FlutterMethodNotImplemented)
|
|
}
|
|
}
|
|
pip.onPipChanged = { active, positionMs in
|
|
channel.invokeMethod(
|
|
"onPipChanged",
|
|
arguments: ["active": active, "positionMs": positionMs]
|
|
)
|
|
}
|
|
pip.onPlaybackEnded = {
|
|
channel.invokeMethod("onPipPlaybackEnded", arguments: nil)
|
|
}
|
|
}
|
|
|
|
/// 设备标识：IDFV 免权限，卸载本 App 不变，避免客户端自生成的 id 每次重装都变。
|
|
/// 同通道顺带提供设备区域（ISO-2），注册时作为服务端 IP 解析失败后的兜底。
|
|
private func registerDeviceIdChannel(_ engineBridge: FlutterImplicitEngineBridge) {
|
|
let channel = FlutterMethodChannel(
|
|
name: "com.stormg.lumadrama/device",
|
|
binaryMessenger: engineBridge.applicationRegistrar.messenger()
|
|
)
|
|
channel.setMethodCallHandler { call, result in
|
|
switch call.method {
|
|
case "idfv":
|
|
result(UIDevice.current.identifierForVendor?.uuidString)
|
|
case "region":
|
|
if #available(iOS 16.0, *) {
|
|
result(Locale.current.region?.identifier)
|
|
} else {
|
|
result(Locale.current.regionCode)
|
|
}
|
|
default:
|
|
result(FlutterMethodNotImplemented)
|
|
}
|
|
}
|
|
}
|
|
|
|
private func registerWirelessDataChannel(_ engineBridge: FlutterImplicitEngineBridge) {
|
|
let channel = FlutterMethodChannel(
|
|
name: WirelessDataPrompt.channelName,
|
|
binaryMessenger: engineBridge.applicationRegistrar.messenger()
|
|
)
|
|
channel.setMethodCallHandler { [weak self] call, result in
|
|
guard call.method == WirelessDataPrompt.awaitDecisionMethod else {
|
|
result(FlutterMethodNotImplemented)
|
|
return
|
|
}
|
|
guard let self else {
|
|
result(nil)
|
|
return
|
|
}
|
|
self.wirelessDataPrompt.awaitDecision(result)
|
|
}
|
|
}
|
|
}
|