enchantedwyf/tuiche
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

提交缺失语言文件

Browse Source
This commit is contained in:
wyf
2026-01-31 14:44:55 +08:00
parent 97ffc1220d
commit 144de2c965
5 changed files with 1038 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
lib/common/util/base64Tool.dart Normal file
View File

@@ -0,0 +1,24 @@
import 'dart:convert';
class Base64Tool {
/// 编码为 URL 安全的 Base64（网络请求用这个就够了）
static String encode(String text) {
final base64Str = base64.encode(utf8.encode(text));
return base64Str
.replaceAll('+', '-')
.replaceAll('/', '_')
.replaceAll('=', '');
}
/// 解码 URL 安全的 Base64
static String decode(String urlSafeBase64) {
var base64Str = urlSafeBase64.replaceAll('-', '+').replaceAll('_', '/');
// 补充等号
while (base64Str.length % 4 != 0) {
base64Str += '=';
}
return utf8.decode(base64.decode(base64Str));
}
}

13
lib/enum/NetworkType.dart Normal file
View File

@@ -0,0 +1,13 @@
// 网络类型枚举
enum NetworkType {
none('无网络'),
wifi('WiFi'),
cellular('移动网络'),
ethernet('以太网'),
bluetooth('蓝牙'),
vpn('VPN'),
other('其他网络');
final String description;
const NetworkType(this.description);
}

12
lib/enum/SignalLevel.dart Normal file
View File

@@ -0,0 +1,12 @@
// 信号强度等级枚举
enum SignalLevel {
none(0, '无信号'),
poor(1, '信号弱'),
fair(2, '信号中'),
good(3, '信号良'),
excellent(4, '信号强');
final int level;
final String description;
const SignalLevel(this.level, this.description);
}

327
lib/network/NetworkStatusController.dart Normal file
View File

@@ -0,0 +1,327 @@
import 'dart:async';
import 'package:connectivity_plus/connectivity_plus.dart';
import 'package:flutter/material.dart';
import 'package:get/get.dart';
import 'package:vbvs_app/enum/NetworkType.dart';
import 'package:vbvs_app/enum/SignalLevel.dart';
import 'package:vbvs_app/pages/mh_page/test/WebviewTestModel.dart';
class NetworkStatusController extends GetxController {
static NetworkStatusController get instance =>
Get.find<NetworkStatusController>();
// 响应式变量
final Rx<NetworkType> _networkType = NetworkType.none.obs;
final Rx<SignalLevel> _signalLevel = SignalLevel.none.obs;
final RxInt _signalStrength = 0.obs;
final RxBool _isLoading = true.obs;
// 上一次发送的网络状态（用于避免重复发送相同状态）
String _lastSentNetworkType = '';
int _lastSentSignalStrength = 0;
// 实例
final Connectivity _connectivity = Connectivity();
StreamSubscription? _subscription;
// Getters
NetworkType get networkType => _networkType.value;
SignalLevel get signalLevel => _signalLevel.value;
int get signalStrength => _signalStrength.value;
bool get isLoading => _isLoading.value;
// 便利方法
bool get isUsingWifi => networkType == NetworkType.wifi;
bool get isUsingCellular => networkType == NetworkType.cellular;
bool get isConnected => networkType != NetworkType.none;
@override
void onInit() {
super.onInit();
print('网络-----> NetworkStatusController onInit() 开始执行');
_initNetworkMonitoring();
}
Future<void> _initNetworkMonitoring() async {
_isLoading.value = true;
try {
// 初始检查
await _checkNetworkStatus();
// 监听网络变化
_subscription = _connectivity.onConnectivityChanged
.listen((List<ConnectivityResult> results) {
_updateNetworkType(results);
_checkNetworkStatus();
});
// 定期刷新网络状态（每10秒）
Timer.periodic(const Duration(seconds: 10), (timer) {
_checkNetworkStatus();
});
print('网络-----> 网络监控初始化完成');
} catch (e) {
print('网络-----> 网络监控初始化失败: $e');
} finally {
_isLoading.value = false;
}
}
Future<void> _checkNetworkStatus() async {
try {
// 获取连接类型
final connectivityResults = await _connectivity.checkConnectivity();
_updateNetworkType(connectivityResults);
// 根据网络类型设置信号强度
_updateSignalLevelAndStrength();
// 打印当前网络状态
_logCurrentNetworkStatus();
// 发送网络状态到 WebView
_sendNetworkStatusToWebView();
} catch (e) {
print('网络-----> 检查网络状态失败: $e');
}
}
/// 发送网络状态到 WebView
void _sendNetworkStatusToWebView() {
try {
// 检查网络状态是否发生变化
String currentNetworkType = _getNetworkTypeString();
int currentSignalStrength = _signalStrength.value;
// 如果状态没有变化，不重复发送
// if (currentNetworkType == _lastSentNetworkType &&
// currentSignalStrength == _lastSentSignalStrength) {
// return;
// }
// 更新上一次发送的状态
_lastSentNetworkType = currentNetworkType;
_lastSentSignalStrength = currentSignalStrength;
// 准备要发送的数据
Map<String, dynamic> networkData = {
'networkType': currentNetworkType,
'signalStrength': currentSignalStrength,
};
print('网络-----> 发送网络状态到 WebView: $networkData');
// 通过 WebviewTestController 发送到 WebView
if (Get.isRegistered<WebviewTestController>()) {
final webviewTestController = Get.find<WebviewTestController>();
// 检查 jsbridge 是否可用
if (webviewTestController.web.jsbridge?.dart != null) {
webviewTestController.web.jsbridge?.dart?.switchNetWork(networkData);
print('网络-----> 网络状态已成功发送到 WebView');
} else {
print('网络-----> WebView jsbridge 不可用');
}
} else {
print('网络-----> WebviewTestController 未注册');
}
} catch (e) {
print('网络-----> 发送网络状态到 WebView 失败: $e');
}
}
/// 获取网络类型字符串
String _getNetworkTypeString() {
if (isUsingWifi) {
return 'wifi';
} else if (isUsingCellular) {
return 'cellular';
} else {
return 'none';
}
}
void _logCurrentNetworkStatus() {
print('网络-----> 当前网络类型: ${_networkType.value.description}');
print('网络-----> 当前信号等级: ${_signalLevel.value.description}');
print('网络-----> 当前信号强度: ${_signalStrength.value}dBm');
print('网络-----> 是否连接: ${isConnected ? "是" : "否"}');
print('网络-----> 发送到WebView的类型: ${_getNetworkTypeString()}');
}
void _updateNetworkType(List<ConnectivityResult> results) {
if (results.isEmpty) {
_networkType.value = NetworkType.none;
print('网络-----> 网络类型变化: 无网络连接');
return;
}
ConnectivityResult mainResult = results.first;
// 优先选择WiFi
if (results.contains(ConnectivityResult.wifi)) {
mainResult = ConnectivityResult.wifi;
} else if (results.contains(ConnectivityResult.mobile)) {
mainResult = ConnectivityResult.mobile;
}
NetworkType newType;
switch (mainResult) {
case ConnectivityResult.wifi:
newType = NetworkType.wifi;
break;
case ConnectivityResult.mobile:
newType = NetworkType.cellular;
break;
case ConnectivityResult.ethernet:
newType = NetworkType.ethernet;
break;
case ConnectivityResult.bluetooth:
newType = NetworkType.bluetooth;
break;
case ConnectivityResult.vpn:
newType = NetworkType.vpn;
break;
case ConnectivityResult.other:
newType = NetworkType.other;
break;
case ConnectivityResult.none:
default:
newType = NetworkType.none;
break;
}
if (newType != _networkType.value) {
_networkType.value = newType;
print('网络-----> 网络类型变化: ${newType.description}');
}
}
void _updateSignalLevelAndStrength() {
// 根据网络类型设置信号等级和强度
switch (_networkType.value) {
case NetworkType.none:
_signalLevel.value = SignalLevel.none;
_signalStrength.value = 0;
break;
case NetworkType.wifi:
// WiFi连接
_signalLevel.value = SignalLevel.good;
_signalStrength.value = -65; // WiFi正常连接强度
break;
case NetworkType.cellular:
// 移动网络
_signalLevel.value = SignalLevel.good;
_signalStrength.value = -85; // 移动网络正常强度
break;
default:
// 其他网络类型
_signalLevel.value = SignalLevel.good;
_signalStrength.value = -60;
break;
}
print(
'网络-----> 信号等级: ${_signalLevel.value.description}, 强度: ${_signalStrength.value}dBm');
}
/// 手动刷新网络状态并发送到 WebView
Future<void> refresh() async {
await _checkNetworkStatus();
}
/// 获取网络状态描述
String getNetworkStatusDescription() {
if (isUsingWifi) {
return 'WiFi，信号${signalLevel.description}';
} else if (isUsingCellular) {
return '移动网络，信号${signalLevel.description}';
} else {
return '无网络连接';
}
}
/// 获取网络状态颜色
Color getNetworkStatusColor() {
switch (signalLevel) {
case SignalLevel.excellent:
case SignalLevel.good:
return Colors.green;
case SignalLevel.fair:
return Colors.orange;
case SignalLevel.poor:
case SignalLevel.none:
return Colors.red;
}
}
/// 获取WiFi图标
IconData getWifiIcon() {
if (!isUsingWifi) return Icons.signal_wifi_off;
switch (signalLevel) {
case SignalLevel.excellent:
return Icons.signal_wifi_4_bar;
case SignalLevel.good:
return Icons.signal_wifi_4_bar;
case SignalLevel.fair:
return Icons.signal_wifi_4_bar;
case SignalLevel.poor:
return Icons.signal_wifi_4_bar;
case SignalLevel.none:
return Icons.signal_wifi_off;
}
}
/// 获取蜂窝网络图标
IconData getCellularIcon() {
switch (signalLevel) {
case SignalLevel.excellent:
case SignalLevel.good:
return Icons.signal_cellular_4_bar;
case SignalLevel.fair:
return Icons.signal_cellular_4_bar;
case SignalLevel.poor:
return Icons.signal_cellular_4_bar;
case SignalLevel.none:
return Icons.signal_cellular_0_bar;
}
}
/// 获取当前应该显示的图标
IconData getCurrentNetworkIcon() {
if (isUsingWifi) {
return getWifiIcon();
} else if (isUsingCellular) {
return getCellularIcon();
} else {
return Icons.signal_wifi_off;
}
}
/// 获取当前网络状态数据（供外部调用）
Map<String, dynamic> getCurrentNetworkData() {
return {
'networkType': _getNetworkTypeString(),
'signalStrength': signalStrength,
};
}
/// 手动发送网络状态到 WebView（供外部调用）
void sendNetworkStatus() {
_sendNetworkStatusToWebView();
}
@override
void onClose() {
_subscription?.cancel();
print('网络-----> NetworkStatusController 已关闭');
super.onClose();
}
}