603 lines
21 KiB
Dart
603 lines
21 KiB
Dart
import 'package:flutter/services.dart';
|
||
|
||
import 'package:pj_supermarket_cloud/common/models/manage/root_access_models.dart';
|
||
|
||
/// 当前 Android 设备的运行环境。
|
||
class AppRuntimeEnvironment {
|
||
/// 是否命中 Android 虚拟机特征；通道不可用时按真机降级，避免阻塞应用启动。
|
||
final bool isEmulator;
|
||
|
||
/// Android DisplayManager 当前识别的显示屏数量，最少按单屏处理。
|
||
final int displayCount;
|
||
|
||
/// 当前 Android 系统发行版本，例如 `11`；原生字段不可用时为空字符串。
|
||
final String androidVersion;
|
||
|
||
/// 当前 Android API Level，例如 Android 11 对应 30；原生字段不可用时为 0。
|
||
final int androidSdkInt;
|
||
|
||
/// 当前进程实际安装 APK 的展示版本，不使用后台待更新版本代替。
|
||
final String apkVersionName;
|
||
|
||
/// 当前进程实际安装 APK 的内部版本码；原生字段不可用时为 0。
|
||
final int apkVersionCode;
|
||
|
||
/// 创建一份由 Android 原生运行时采集的不可变环境快照。
|
||
const AppRuntimeEnvironment({
|
||
required this.isEmulator,
|
||
required this.displayCount,
|
||
required this.androidVersion,
|
||
required this.androidSdkInt,
|
||
required this.apkVersionName,
|
||
required this.apkVersionCode,
|
||
});
|
||
|
||
/// 从 MethodChannel 返回值解析环境快照，缺失版本字段使用可安全展示的空值。
|
||
factory AppRuntimeEnvironment.fromMap(Map<dynamic, dynamic>? data) {
|
||
return AppRuntimeEnvironment(
|
||
isEmulator: data?['isEmulator'] == true,
|
||
displayCount: (data?['displayCount'] as num?)?.toInt() ?? 1,
|
||
androidVersion: data?['androidVersion']?.toString() ?? '',
|
||
androidSdkInt: (data?['androidSdkInt'] as num?)?.toInt() ?? 0,
|
||
apkVersionName: data?['apkVersionName']?.toString() ?? '',
|
||
apkVersionCode: (data?['apkVersionCode'] as num?)?.toInt() ?? 0,
|
||
);
|
||
}
|
||
}
|
||
|
||
/// Android 专用设备模式的实时状态。
|
||
class AppKioskStatus {
|
||
final bool deviceAdminActive;
|
||
final bool deviceOwner;
|
||
final bool available;
|
||
final bool active;
|
||
final bool lockTaskPermitted;
|
||
final bool autoEnterEnabled;
|
||
final bool bootAutoStartSupported;
|
||
|
||
const AppKioskStatus({
|
||
required this.deviceAdminActive,
|
||
required this.deviceOwner,
|
||
required this.available,
|
||
required this.active,
|
||
required this.lockTaskPermitted,
|
||
required this.autoEnterEnabled,
|
||
required this.bootAutoStartSupported,
|
||
});
|
||
|
||
const AppKioskStatus.unavailable()
|
||
: deviceAdminActive = false,
|
||
deviceOwner = false,
|
||
available = false,
|
||
active = false,
|
||
lockTaskPermitted = false,
|
||
autoEnterEnabled = false,
|
||
bootAutoStartSupported = false;
|
||
|
||
factory AppKioskStatus.fromMap(Map<dynamic, dynamic>? data) {
|
||
return AppKioskStatus(
|
||
deviceAdminActive: data?['deviceAdminActive'] == true,
|
||
deviceOwner: data?['deviceOwner'] == true,
|
||
available: data?['available'] == true,
|
||
active: data?['active'] == true,
|
||
lockTaskPermitted: data?['lockTaskPermitted'] == true,
|
||
autoEnterEnabled: data?['autoEnterEnabled'] == true,
|
||
bootAutoStartSupported: data?['bootAutoStartSupported'] == true,
|
||
);
|
||
}
|
||
|
||
bool get canExitToAndroidHome => available && active;
|
||
|
||
String get statusLabel {
|
||
if (!available) return '暂不可实现';
|
||
if (active && !autoEnterEnabled) return 'Kiosk 运行中 · 自动开启已关闭';
|
||
if (active) return '可以实现 · Kiosk 运行中';
|
||
if (!autoEnterEnabled) return '可以实现 · 自动开启已关闭';
|
||
if (lockTaskPermitted) return '可以实现 · 正在进入';
|
||
return '可以实现 · 等待策略生效';
|
||
}
|
||
|
||
String get description {
|
||
if (available && active && !autoEnterEnabled) {
|
||
return '当前仍在 Kiosk；管理员退出后，再次打开或回到 App 将不再自动锁定。';
|
||
}
|
||
if (available && !autoEnterEnabled) {
|
||
return '设备具备 Device Owner 权限；开启右侧配置后，每次打开或回到 App 都会自动进入 Kiosk。';
|
||
}
|
||
if (available) {
|
||
return '已配置 Device Owner；每次打开或回到 App 都会自动进入 Kiosk，并隐藏主页、最近任务和系统栏。';
|
||
}
|
||
if (deviceAdminActive) {
|
||
return '当前仅激活了设备管理员，仍不能可靠禁用主页和最近任务；需要配置为 Device Owner。';
|
||
}
|
||
return '未配置 Device Owner，普通全屏不能保证无法退出；需在恢复出厂或未初始化的设备上部署。';
|
||
}
|
||
}
|
||
|
||
/// Root 执行 DPM 后返回的结构化 Kiosk 启用结果。
|
||
class AppKioskProvisionResult {
|
||
/// 创建一份包含稳定错误编码、可操作说明和最新 Kiosk 状态的结果。
|
||
const AppKioskProvisionResult({
|
||
required this.success,
|
||
required this.code,
|
||
required this.message,
|
||
required this.status,
|
||
});
|
||
|
||
/// DPM 是否成功配置当前应用为 Device Owner 并进入 Kiosk。
|
||
final bool success;
|
||
|
||
/// 原生层稳定错误编码，用于区分账户、Owner、用户和厂商限制。
|
||
final String code;
|
||
|
||
/// 面向终端管理员展示的中文处理建议。
|
||
final String message;
|
||
|
||
/// 命令执行完成后重新读取的 Kiosk 实时状态。
|
||
final AppKioskStatus status;
|
||
|
||
/// 从原生结构化返回值恢复结果，通道字段缺失时使用安全失败值。
|
||
factory AppKioskProvisionResult.fromMap(Map<dynamic, dynamic>? data) {
|
||
return AppKioskProvisionResult(
|
||
success: data?['success'] == true,
|
||
code: data?['code']?.toString() ?? 'UNKNOWN',
|
||
message: data?['message']?.toString() ?? 'Kiosk 启用失败，请检查设备策略',
|
||
status: AppKioskStatus.fromMap(data?['status'] as Map?),
|
||
);
|
||
}
|
||
}
|
||
|
||
/// Android APK 校验或 Root 安装命令的结构化结果。
|
||
class AppApkOperationResult {
|
||
/// 创建一份供自动更新流程判断的原生操作结果。
|
||
const AppApkOperationResult({
|
||
required this.success,
|
||
required this.code,
|
||
required this.message,
|
||
this.versionCode,
|
||
});
|
||
|
||
/// APK 校验通过或安装命令成功执行时为 true。
|
||
final bool success;
|
||
|
||
/// 原生稳定结果编码，例如 SIGNATURE_MISMATCH 或 INSTALL_STARTED。
|
||
final String code;
|
||
|
||
/// 面向任务日志或人工操作展示的中文摘要。
|
||
final String message;
|
||
|
||
/// 原生 APK 实际版本码；返回数据不含版本时为空。
|
||
final int? versionCode;
|
||
|
||
/// 从 MethodChannel 返回映射创建操作结果。
|
||
factory AppApkOperationResult.fromMap(Map<dynamic, dynamic>? data) {
|
||
return AppApkOperationResult(
|
||
success: data?['valid'] == true,
|
||
code: data?['code']?.toString() ?? 'UNKNOWN',
|
||
message: data?['message']?.toString() ?? '原生 APK 操作失败',
|
||
versionCode: (data?['versionCode'] as num?)?.toInt(),
|
||
);
|
||
}
|
||
}
|
||
|
||
/// 应用启动时消费的待更新恢复结果。
|
||
class AppUpdateRecoveryResult {
|
||
/// 创建一份待更新确认结果。
|
||
const AppUpdateRecoveryResult({
|
||
required this.pending,
|
||
required this.success,
|
||
required this.message,
|
||
});
|
||
|
||
/// 原生层是否存在上次安装前持久化的待更新记录。
|
||
final bool pending;
|
||
|
||
/// 当前安装版本是否达到待更新目标版本码。
|
||
final bool success;
|
||
|
||
/// 启动确认结果摘要，用于完成任务记录。
|
||
final String message;
|
||
|
||
/// 从 MethodChannel 返回映射创建恢复结果。
|
||
factory AppUpdateRecoveryResult.fromMap(Map<dynamic, dynamic>? data) {
|
||
return AppUpdateRecoveryResult(
|
||
pending: data?['pending'] == true,
|
||
success: data?['success'] == true,
|
||
message: data?['message']?.toString() ?? '没有待确认的自动更新',
|
||
);
|
||
}
|
||
}
|
||
|
||
class AppNetworkSnapshot {
|
||
final bool connected;
|
||
final String type;
|
||
final int receivedBytes;
|
||
final int transmittedBytes;
|
||
|
||
const AppNetworkSnapshot({
|
||
required this.connected,
|
||
required this.type,
|
||
required this.receivedBytes,
|
||
required this.transmittedBytes,
|
||
});
|
||
|
||
factory AppNetworkSnapshot.fromMap(Map<dynamic, dynamic>? data) {
|
||
return AppNetworkSnapshot(
|
||
connected: data?['connected'] == true,
|
||
type: data?['type']?.toString() ?? 'offline',
|
||
receivedBytes: (data?['rxBytes'] as num?)?.toInt() ?? 0,
|
||
transmittedBytes: (data?['txBytes'] as num?)?.toInt() ?? 0,
|
||
);
|
||
}
|
||
}
|
||
|
||
/// Android 进程与设备资源快照。
|
||
///
|
||
/// CPU 使用率需要比较两次 [processCpuTimeMillis]，原生层只返回累计值，避免在平台通道内
|
||
/// 持有采样定时器；内存和存储同时保留总量，便于顶栏给出百分比并在 Tooltip 展示明细。
|
||
class AppPerformanceSnapshot {
|
||
/// Android 系统自本次开机后的运行时长，单位为秒。
|
||
final int systemUptimeSeconds;
|
||
|
||
/// 当前应用进程自启动后的运行时长，单位为秒。
|
||
final int appUptimeSeconds;
|
||
|
||
/// Android 进程从启动至采样时累计消耗的 CPU 时间，单位为毫秒。
|
||
final int processCpuTimeMillis;
|
||
|
||
/// Android Runtime 报告的逻辑处理器数量，最小按 1 处理。
|
||
final int logicalProcessorCount;
|
||
|
||
/// 系统物理内存总量，单位为字节；平台数据不可用时为 0。
|
||
final int systemMemoryTotalBytes;
|
||
|
||
/// 系统当前可用物理内存，单位为字节；平台数据不可用时为 0。
|
||
final int systemMemoryAvailableBytes;
|
||
|
||
/// 当前应用进程的 PSS 内存占用，单位为字节。
|
||
final int appMemoryBytes;
|
||
|
||
/// 应用文件目录所在存储卷的总容量，单位为字节；平台数据不可用时为 0。
|
||
final int storageTotalBytes;
|
||
|
||
/// 应用文件目录所在存储卷的可用容量，单位为字节；平台数据不可用时为 0。
|
||
final int storageAvailableBytes;
|
||
|
||
/// 创建一份原生平台已经完成单位换算的资源快照。
|
||
const AppPerformanceSnapshot({
|
||
required this.systemUptimeSeconds,
|
||
required this.appUptimeSeconds,
|
||
required this.processCpuTimeMillis,
|
||
required this.logicalProcessorCount,
|
||
required this.systemMemoryTotalBytes,
|
||
required this.systemMemoryAvailableBytes,
|
||
required this.appMemoryBytes,
|
||
required this.storageTotalBytes,
|
||
required this.storageAvailableBytes,
|
||
});
|
||
|
||
/// 创建平台通道不可用时的空快照，百分比 Getter 将稳定返回 0。
|
||
const AppPerformanceSnapshot.empty()
|
||
: systemUptimeSeconds = 0,
|
||
appUptimeSeconds = 0,
|
||
processCpuTimeMillis = 0,
|
||
logicalProcessorCount = 1,
|
||
systemMemoryTotalBytes = 0,
|
||
systemMemoryAvailableBytes = 0,
|
||
appMemoryBytes = 0,
|
||
storageTotalBytes = 0,
|
||
storageAvailableBytes = 0;
|
||
|
||
/// 从 Android MethodChannel 返回值解析资源快照，缺失或类型异常字段按 0 处理。
|
||
factory AppPerformanceSnapshot.fromMap(Map<dynamic, dynamic>? data) {
|
||
int value(String key) => (data?[key] as num?)?.toInt() ?? 0;
|
||
return AppPerformanceSnapshot(
|
||
systemUptimeSeconds: value('systemUptimeSeconds'),
|
||
appUptimeSeconds: value('appUptimeSeconds'),
|
||
processCpuTimeMillis: value('processCpuTimeMs'),
|
||
logicalProcessorCount:
|
||
value('logicalProcessorCount').clamp(1, 256).toInt(),
|
||
systemMemoryTotalBytes: value('memoryTotalBytes'),
|
||
systemMemoryAvailableBytes: value('memoryAvailableBytes'),
|
||
appMemoryBytes: value('appMemoryBytes'),
|
||
storageTotalBytes: value('storageTotalBytes'),
|
||
storageAvailableBytes: value('storageAvailableBytes'),
|
||
);
|
||
}
|
||
|
||
/// 系统内存已使用比例，范围为 0 到 1；总量未知时返回 0。
|
||
double get memoryUsageRatio => _usedRatio(
|
||
total: systemMemoryTotalBytes,
|
||
available: systemMemoryAvailableBytes,
|
||
);
|
||
|
||
/// 应用所在存储卷已使用比例，范围为 0 到 1；总量未知时返回 0。
|
||
double get storageUsageRatio => _usedRatio(
|
||
total: storageTotalBytes,
|
||
available: storageAvailableBytes,
|
||
);
|
||
|
||
/// 根据总量和可用量计算受限于 0 到 1 的占用比例，容忍原生瞬时采样误差。
|
||
static double _usedRatio({required int total, required int available}) {
|
||
if (total <= 0) return 0;
|
||
return ((total - available) / total).clamp(0, 1).toDouble();
|
||
}
|
||
}
|
||
|
||
/// 统一管理虚拟机识别和硬件手动输入模式，避免各业务页面自行猜测设备能力。
|
||
abstract class AppRuntimeTool {
|
||
static const MethodChannel _channel = MethodChannel(
|
||
'biz_xfj/runtime_environment',
|
||
);
|
||
|
||
static AppRuntimeEnvironment _environment = const AppRuntimeEnvironment(
|
||
isEmulator: false,
|
||
displayCount: 1,
|
||
androidVersion: '',
|
||
androidSdkInt: 0,
|
||
apkVersionName: '',
|
||
apkVersionCode: 0,
|
||
);
|
||
static bool _initialized = false;
|
||
static bool _manualHardwareInput = false;
|
||
static AppKioskStatus _kioskStatus = const AppKioskStatus.unavailable();
|
||
|
||
/// 请求 Android 终端执行短震动；通道不可用或平台不支持时回退到 Flutter 触觉反馈。
|
||
static Future<void> vibrate({int durationMs = 60}) async {
|
||
final safeDuration = durationMs.clamp(20, 200).toInt();
|
||
try {
|
||
final handled = await _channel.invokeMethod<bool>(
|
||
'vibrate',
|
||
{'durationMs': safeDuration},
|
||
);
|
||
if (handled == true) return;
|
||
} on MissingPluginException {
|
||
// 非 Android 平台没有运行时通道，继续使用 Flutter 提供的系统触觉能力。
|
||
} on PlatformException {
|
||
// 厂商设备禁用震动或原生调用异常时，回退触觉不能影响弹框关闭控制。
|
||
}
|
||
await HapticFeedback.mediumImpact();
|
||
}
|
||
|
||
static bool get isEmulator => _environment.isEmulator;
|
||
|
||
static int get displayCount => _environment.displayCount;
|
||
|
||
/// 返回设置页使用的 Android 发行版本与 API Level，通道不可用时明确显示未知。
|
||
static String get androidVersionLabel {
|
||
final version = _environment.androidVersion.trim();
|
||
final sdk = _environment.androidSdkInt;
|
||
if (version.isNotEmpty && sdk > 0) return 'Android $version（API $sdk）';
|
||
if (version.isNotEmpty) return 'Android $version';
|
||
if (sdk > 0) return 'Android API $sdk';
|
||
return '未知';
|
||
}
|
||
|
||
/// 返回当前实际安装 APK 的展示版本与 Build，字段缺失时仍保留已知部分。
|
||
static String get apkVersionLabel {
|
||
final versionName = _environment.apkVersionName.trim();
|
||
final versionCode = _environment.apkVersionCode;
|
||
if (versionName.isNotEmpty && versionCode > 0) {
|
||
return '$versionName（Build $versionCode）';
|
||
}
|
||
if (versionName.isNotEmpty) return versionName;
|
||
if (versionCode > 0) return 'Build $versionCode';
|
||
return '未知';
|
||
}
|
||
|
||
/// 虚拟机始终使用手动输入；真机可在设置中主动开启手动输入模式。
|
||
static bool get useManualHardwareInput => isEmulator || _manualHardwareInput;
|
||
|
||
static bool get canUsePhysicalHardware => !useManualHardwareInput;
|
||
|
||
static bool get hasMultipleDisplays => displayCount >= 2;
|
||
|
||
static AppKioskStatus get kioskStatus => _kioskStatus;
|
||
|
||
static Future<void> initializePlatform() async {
|
||
if (_initialized) return;
|
||
try {
|
||
final data = await _channel.invokeMapMethod<dynamic, dynamic>(
|
||
'getRuntimeEnvironment',
|
||
);
|
||
_environment = AppRuntimeEnvironment.fromMap(data);
|
||
_kioskStatus = await refreshKioskStatus();
|
||
} on PlatformException {
|
||
// 原生通道异常时按单屏处理，避免错误地启动副屏。
|
||
_environment = const AppRuntimeEnvironment(
|
||
isEmulator: false,
|
||
displayCount: 1,
|
||
androidVersion: '',
|
||
androidSdkInt: 0,
|
||
apkVersionName: '',
|
||
apkVersionCode: 0,
|
||
);
|
||
_kioskStatus = const AppKioskStatus.unavailable();
|
||
}
|
||
_initialized = true;
|
||
}
|
||
|
||
static Future<AppKioskStatus> refreshKioskStatus() async {
|
||
try {
|
||
final data = await _channel.invokeMapMethod<dynamic, dynamic>(
|
||
'getKioskStatus',
|
||
);
|
||
_kioskStatus = AppKioskStatus.fromMap(data);
|
||
} on PlatformException {
|
||
_kioskStatus = const AppKioskStatus.unavailable();
|
||
}
|
||
return _kioskStatus;
|
||
}
|
||
|
||
/// 配置每次进入 App 时是否自动恢复 Kiosk，配置由 Android 原生层持久化。
|
||
static Future<AppKioskStatus> setKioskAutoEnterEnabled(bool enabled) async {
|
||
try {
|
||
final data = await _channel.invokeMapMethod<dynamic, dynamic>(
|
||
'setKioskAutoEnterEnabled',
|
||
{'enabled': enabled},
|
||
);
|
||
_kioskStatus = AppKioskStatus.fromMap(data);
|
||
} on PlatformException {
|
||
// 保留原状态，设置页会据此判断本次配置没有生效。
|
||
}
|
||
return _kioskStatus;
|
||
}
|
||
|
||
/// 用户确认后通过 Root 请求 Android 配置当前应用为 Device Owner，并立即进入 Kiosk。
|
||
static Future<AppKioskProvisionResult> enableKioskWithRoot() async {
|
||
try {
|
||
final data = await _channel.invokeMapMethod<dynamic, dynamic>(
|
||
'enableKioskWithRoot',
|
||
);
|
||
final provision = AppKioskProvisionResult.fromMap(data);
|
||
_kioskStatus = provision.status;
|
||
return provision;
|
||
} on PlatformException catch (error) {
|
||
return AppKioskProvisionResult(
|
||
success: false,
|
||
code: error.code,
|
||
message: error.message ?? 'Kiosk 启用失败，请稍后重试',
|
||
status: _kioskStatus,
|
||
);
|
||
}
|
||
}
|
||
|
||
/// 执行带原生 5 秒超时的 `su -c id`，只有退出码为零且输出确认 uid=0 才返回可用。
|
||
static Future<RootAccessCheckResult> checkRootAccess() async {
|
||
try {
|
||
final data = await _channel.invokeMapMethod<dynamic, dynamic>(
|
||
'checkRootAccess',
|
||
);
|
||
return RootAccessCheckResult.fromMap(data);
|
||
} on PlatformException catch (error) {
|
||
return RootAccessCheckResult(
|
||
status: RootAccessStatus.unavailable,
|
||
checkedAt: DateTime.now(),
|
||
diagnostic: error.message ?? 'Root 检查通道不可用',
|
||
);
|
||
}
|
||
}
|
||
|
||
/// 由 Android PackageManager 校验 APK 包名、签名和目标版本码。
|
||
static Future<AppApkOperationResult> validateApk({
|
||
required String path,
|
||
required int expectedVersionCode,
|
||
}) async {
|
||
try {
|
||
final data = await _channel.invokeMapMethod<dynamic, dynamic>(
|
||
'validateApk',
|
||
{'path': path, 'expectedVersionCode': expectedVersionCode},
|
||
);
|
||
return AppApkOperationResult.fromMap(data);
|
||
} on PlatformException catch (error) {
|
||
return AppApkOperationResult(
|
||
success: false,
|
||
code: error.code,
|
||
message: error.message ?? 'APK 校验失败',
|
||
);
|
||
}
|
||
}
|
||
|
||
/// 安装前由原生层再次校验 Root 与 APK，并执行不降级、不卸载数据的 `pm install -r`。
|
||
static Future<AppApkOperationResult> installApkWithRoot({
|
||
required String path,
|
||
required int expectedVersionCode,
|
||
}) async {
|
||
try {
|
||
final data = await _channel.invokeMapMethod<dynamic, dynamic>(
|
||
'installApkWithRoot',
|
||
{'path': path, 'expectedVersionCode': expectedVersionCode},
|
||
);
|
||
return AppApkOperationResult.fromMap(data);
|
||
} on PlatformException catch (error) {
|
||
return AppApkOperationResult(
|
||
success: false,
|
||
code: error.code,
|
||
message: error.message ?? 'APK 安装失败',
|
||
);
|
||
}
|
||
}
|
||
|
||
/// 启动时消费原生待更新状态，确认版本后原生层同步清理私有 APK。
|
||
static Future<AppUpdateRecoveryResult> consumePendingUpdate() async {
|
||
try {
|
||
final data = await _channel.invokeMapMethod<dynamic, dynamic>(
|
||
'consumePendingUpdate',
|
||
);
|
||
return AppUpdateRecoveryResult.fromMap(data);
|
||
} on PlatformException catch (error) {
|
||
return AppUpdateRecoveryResult(
|
||
pending: false,
|
||
success: false,
|
||
message: error.message ?? '自动更新恢复检查失败',
|
||
);
|
||
}
|
||
}
|
||
|
||
/// 只有原生层确认 Device Owner/Kiosk 可用时才允许退出到系统桌面。
|
||
static Future<bool> exitKioskToAndroidHome() async {
|
||
if (!_kioskStatus.canExitToAndroidHome) return false;
|
||
try {
|
||
return await _channel.invokeMethod<bool>('exitKioskToHome') ?? false;
|
||
} on PlatformException {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
static Future<AppNetworkSnapshot> getNetworkSnapshot() async {
|
||
try {
|
||
final data = await _channel.invokeMapMethod<dynamic, dynamic>(
|
||
'getNetworkSnapshot',
|
||
);
|
||
return AppNetworkSnapshot.fromMap(data);
|
||
} on PlatformException {
|
||
return const AppNetworkSnapshot(
|
||
connected: false,
|
||
type: 'offline',
|
||
receivedBytes: 0,
|
||
transmittedBytes: 0,
|
||
);
|
||
}
|
||
}
|
||
|
||
/// 读取一次 Android 进程、内存和存储快照；通道失败时返回可安全展示的空快照。
|
||
static Future<AppPerformanceSnapshot> getPerformanceSnapshot() async {
|
||
try {
|
||
final data = await _channel.invokeMapMethod<dynamic, dynamic>(
|
||
'getPerformanceSnapshot',
|
||
);
|
||
return AppPerformanceSnapshot.fromMap(data);
|
||
} on PlatformException {
|
||
return const AppPerformanceSnapshot.empty();
|
||
}
|
||
}
|
||
|
||
/// 查询插件当前 Presentation 是否仍在展示，用于避免 showSubDisplay() 先关后开造成闪屏。
|
||
static Future<bool> isSubScreenShowing() async {
|
||
try {
|
||
return await _channel.invokeMethod<bool>('isSubScreenShowing') ?? false;
|
||
} on PlatformException {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/// 单向转发业务状态到副屏 Engine，原生层转发后立即回包。
|
||
///
|
||
/// 锁定的双屏插件不会结束普通业务消息的主屏 MethodChannel 请求，因此人脸等
|
||
/// 硬件主链路必须使用此入口，避免等待副屏回包导致 Camera 初始化被永久阻塞。
|
||
static Future<bool> sendViceMessage(
|
||
String method, {
|
||
Map<String, dynamic>? params,
|
||
}) async {
|
||
return await _channel.invokeMethod<bool>('sendViceMessage', {
|
||
'method': method,
|
||
'params': params ?? <String, dynamic>{},
|
||
}) ??
|
||
false;
|
||
}
|
||
|
||
static void applyManualHardwareInput(bool enabled) {
|
||
_manualHardwareInput = enabled;
|
||
}
|
||
}
|