416 lines
15 KiB
Dart
Executable File
416 lines
15 KiB
Dart
Executable File
import 'dart:async';
|
|
import 'dart:io';
|
|
import 'package:connectivity_plus/connectivity_plus.dart';
|
|
import 'package:flutter/material.dart';
|
|
import 'package:flutter_easyloading/flutter_easyloading.dart';
|
|
import 'package:flutter_local_notifications/flutter_local_notifications.dart';
|
|
import 'package:get/get.dart';
|
|
import 'package:permission_handler/permission_handler.dart';
|
|
import 'package:star_lock/appRouters.dart';
|
|
import 'package:star_lock/flavors.dart';
|
|
import 'package:star_lock/login/login/entity/LoginEntity.dart';
|
|
import 'package:star_lock/main/lockDetail/lockDetail/lockDetail_logic.dart';
|
|
import 'package:star_lock/main/lockMian/lockList/lockList_logic.dart';
|
|
import 'package:star_lock/mine/minePersonInfo/minePersonInfoPage/minePersonInfo_entity.dart';
|
|
import 'package:star_lock/talk/starChart/star_chart_manage.dart';
|
|
import 'package:star_lock/tools/eventBusEventManage.dart';
|
|
import 'package:star_lock/tools/push/notification_service.dart';
|
|
import 'package:star_lock/tools/push/xs_jPhush.dart';
|
|
import 'package:star_lock/tools/showTipView.dart';
|
|
import 'package:star_lock/tools/store_service.dart';
|
|
|
|
import '../../../app_settings/app_settings.dart';
|
|
import '../../../blue/blue_manage.dart';
|
|
import '../../../network/api_repository.dart';
|
|
import '../../../talk/udp/udp_help.dart';
|
|
import '../../../tools/baseGetXController.dart';
|
|
import '../../../tools/storage.dart';
|
|
import '../entity/lockListInfo_entity.dart';
|
|
import 'lockMain_state.dart';
|
|
|
|
class LockMainLogic extends BaseGetXController {
|
|
final LockMainState state = LockMainState();
|
|
final List<StreamSubscription<void>> _subscriptions =
|
|
<StreamSubscription<void>>[];
|
|
|
|
Future<LockListInfoEntity> getStarLockInfo(
|
|
{bool isUnShowLoading = false}) async {
|
|
final LockListInfoEntity entity =
|
|
await ApiRepository.to.getStarLockListInfo(
|
|
pageNo: pageNo,
|
|
pageSize: 50,
|
|
isUnShowLoading: isUnShowLoading,
|
|
);
|
|
if (entity.errorCode!.codeIsSuccessful) {
|
|
// AppLog.log('请求列表调用 loadMainDataLogic');
|
|
await loadMainDataLogic(entity.data!);
|
|
// updateZoneOffsetsAndLanguages();
|
|
}
|
|
return entity;
|
|
}
|
|
|
|
//用户信息
|
|
Future<void> getUserInfoRequest() async {
|
|
final MinePersonInfoEntity entity = await ApiRepository.to.getUserInfo();
|
|
if (entity.errorCode!.codeIsSuccessful) {
|
|
final String languageCodeAndCountryCode = entity.data!.lang!;
|
|
if (languageCodeAndCountryCode.isEmpty) {
|
|
await StoreService.to.saveLanguageCode('');
|
|
await Get.updateLocale(Get.deviceLocale!);
|
|
} else if (languageCodeAndCountryCode.contains('-')) {
|
|
final List<String> parts = languageCodeAndCountryCode.split('-');
|
|
final Locale locale = Locale(parts[0], parts[1]);
|
|
await Get.updateLocale(locale);
|
|
await StoreService.to.saveLanguageCode(locale.toString());
|
|
} else if (languageCodeAndCountryCode.contains('_')) {
|
|
final List<String> parts = languageCodeAndCountryCode.split('_');
|
|
final Locale locale = Locale(parts[0], parts[1]);
|
|
await Get.updateLocale(locale);
|
|
AppLog.log('用户信息请求成功 更新locale: $locale');
|
|
await StoreService.to.saveLanguageCode(locale.toString());
|
|
}
|
|
|
|
Storage.setBool(saveIsVip, entity.data!.isVip == 1);
|
|
//当 deviceId 为空或 deviceIds 列表中不包含 deviceId 时，都会再次绑定设备
|
|
if (entity.data!.deviceId != null) {
|
|
if (entity.data!.deviceId!.isEmpty ||
|
|
!entity.data!.deviceIds!.contains(entity.data!.deviceId)) {
|
|
bindPushDevice();
|
|
}
|
|
}
|
|
|
|
if (entity.data!.starchart != null) {
|
|
if (entity.data!.starchart!.starchartId == null) {
|
|
bindStarChart();
|
|
}
|
|
} else {
|
|
StartChartManage().init();
|
|
}
|
|
}
|
|
}
|
|
|
|
Future<void> bindPushDevice() async {
|
|
// 初始化JPush服务并绑定设备ID
|
|
final XSJPushProvider jpushProvider = XSJPushProvider();
|
|
await jpushProvider.initJPushService();
|
|
NotificationService().init(); // 初始化通知服务
|
|
}
|
|
|
|
//绑定星图
|
|
Future<void> bindStarChart() async {
|
|
//初始化星图服务并绑定配置
|
|
await StartChartManage().init();
|
|
}
|
|
|
|
Future<LoginEntity> updateZoneOffsetsAndLanguages() async {
|
|
final LoginEntity entity =
|
|
await ApiRepository.to.updateZoneOffsetsAndLanguages(
|
|
timezoneOffset: DateTime.now().timeZoneOffset.inSeconds,
|
|
// language: ''
|
|
);
|
|
if (entity.errorCode!.codeIsSuccessful) {}
|
|
return entity;
|
|
}
|
|
|
|
Future<void> loadMainDataLogic(LockListInfoGroupEntity entity) async {
|
|
final bool every = entity.groupList?.every((GroupList list) =>
|
|
(list.lockList ?? <LockListInfoItemEntity>[]).isEmpty) ??
|
|
true;
|
|
if ((entity.groupList ?? <GroupList>[]).isEmpty || every) {
|
|
state.dataLength.value = 0;
|
|
} else if (entity.groupList!.length == 1) {
|
|
final GroupList groupList = entity.groupList![0];
|
|
if (groupList.lockList!.length > 1) {
|
|
state.dataLength.value = 2;
|
|
} else {
|
|
state.dataLength.value = 1;
|
|
}
|
|
} else {
|
|
state.dataLength.value = 2;
|
|
}
|
|
state.lockListInfoGroupEntity.value = entity;
|
|
state.lockListInfoGroupEntity.refresh();
|
|
// AppLog.log('entity:$entity state.lockListInfoGroupEntity.value.groupList!.length:${state.lockListInfoGroupEntity.value.groupList![0].lockList!.length}');
|
|
//检测控制器是否存在
|
|
eventBus.fire(SetLockListInfoGroupEntity(lockListInfoGroupEntity: entity));
|
|
// if (Get.isRegistered<LockListLogic>()) {
|
|
// //设置控制器数据并刷新
|
|
// // AppLog.log('检测控制器是否存 调用了 setLockListInfoGroupEntity');
|
|
// Get.find<LockListLogic>().setLockListInfoGroupEntity(entity);
|
|
// } else {
|
|
// //延迟加载
|
|
// Future<dynamic>.delayed(500.milliseconds, () {
|
|
// if (Get.isRegistered<LockListLogic>()) {
|
|
// //设置控制器数据并刷新
|
|
// // AppLog.log('检测控制器是否存 延迟调用了 setLockListInfoGroupEntity');
|
|
// Get.find<LockListLogic>().setLockListInfoGroupEntity(entity);
|
|
// }
|
|
// });
|
|
// }
|
|
|
|
if (state.dataLength.value == 1) {
|
|
if (Get.isRegistered<LockDetailLogic>()) {
|
|
//设置控制器数据并刷新
|
|
// AppLog.log('检测控制器是否存 调用了 setLockListInfoGroupEntity');
|
|
Get.find<LockDetailLogic>().loadData(
|
|
lockListInfoItemEntity: entity.groupList![0].lockList![0],
|
|
isOnlyOneData: true);
|
|
} else {
|
|
//延迟加载
|
|
Future<dynamic>.delayed(200.milliseconds, () {
|
|
if (Get.isRegistered<LockDetailLogic>()) {
|
|
//设置控制器数据并刷新
|
|
// AppLog.log('检测控制器是否存 延迟调用了 setLockListInfoGroupEntity');
|
|
Get.find<LockDetailLogic>().loadData(
|
|
lockListInfoItemEntity: entity.groupList![0].lockList![0],
|
|
isOnlyOneData: true);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
await Storage.saveMainListData(entity);
|
|
}
|
|
|
|
/// 获取联网类型
|
|
// Future<void> _getConnectType() async {
|
|
// final ConnectivityResult connectResult =
|
|
// await Connectivity().checkConnectivity();
|
|
// if (connectResult == ConnectivityResult.mobile) {
|
|
// // _netType = "4G";
|
|
// state.networkConnectionStatus.value = 1;
|
|
// AppLog.log('网络连接: 4G 4G 4G 4G 4G');
|
|
// } else if (connectResult == ConnectivityResult.wifi) {
|
|
// // _netType = "wifi";
|
|
// state.networkConnectionStatus.value = 1;
|
|
// AppLog.log('网络连接: wifi wifi wifi wifi wifi');
|
|
// } else {
|
|
// // _netType = "未连接";
|
|
// state.networkConnectionStatus.value = 0;
|
|
// AppLog.log('网络连接: 未连接 未连接 未连接 未连接 未连接');
|
|
// // showToast("网络访问失败，请检查网络是否正常");
|
|
// }
|
|
// }
|
|
|
|
/// 判断网络是否连接
|
|
Future<bool> isConnected() async {
|
|
final List<ConnectivityResult> connectResults =
|
|
await Connectivity().checkConnectivity();
|
|
return !connectResults.contains(ConnectivityResult.none);
|
|
}
|
|
|
|
/// 设置网络切换监听
|
|
// Future<void> connectListener() async {
|
|
// Connectivity().onConnectivityChanged.listen((ConnectivityResult result) {
|
|
// AppLog.log('设置网络切换监听:$result');
|
|
// if (state.networkConnectionStatus.value == 0 && result != ConnectivityResult.none) {
|
|
// // 从无网络到有网络
|
|
// state.networkConnectionStatus.value = 1;
|
|
// getStarLockInfo(isUnShowLoading: true);
|
|
// } else if (result == ConnectivityResult.none) {
|
|
// state.networkConnectionStatus.value = 0;
|
|
// }
|
|
// });
|
|
// }
|
|
|
|
/// 判断是否有网络
|
|
Future<bool> judgeTheNetwork() async {
|
|
final bool isNetwork = await isConnected();
|
|
if (!isNetwork) {
|
|
EasyLoading.showToast('网络访问失败,请检查网络是否正常'.tr);
|
|
}
|
|
return isNetwork;
|
|
}
|
|
|
|
/// 检测推送是否开启
|
|
Future<void> checkWhetherPushIsEnabled() async {
|
|
bool notificationEnabled = false;
|
|
|
|
if (Platform.isAndroid) {
|
|
notificationEnabled = await FlutterLocalNotificationsPlugin()
|
|
.resolvePlatformSpecificImplementation<
|
|
AndroidFlutterLocalNotificationsPlugin>()
|
|
?.areNotificationsEnabled() ??
|
|
false;
|
|
} else if (Platform.isIOS) {
|
|
notificationEnabled = await FlutterLocalNotificationsPlugin()
|
|
.resolvePlatformSpecificImplementation<
|
|
IOSFlutterLocalNotificationsPlugin>()
|
|
?.requestPermissions(
|
|
alert: true,
|
|
badge: false,
|
|
sound: true,
|
|
) ??
|
|
false;
|
|
}
|
|
if (!notificationEnabled) {
|
|
//推送未开启
|
|
ShowTipView().showIosTipWithContentDialog(
|
|
'为了让您及时收到重要通知和更新，我们需要获取通知权限。请点击“确定”按钮，然后在设置页面中启用通知权限。', () async {
|
|
openAppSettings();
|
|
});
|
|
}
|
|
}
|
|
|
|
//刷新锁设备
|
|
Future<void> flushedStarLockInfo(int keyId, int lockId) async {
|
|
AppLog.log('刷新锁设备: keyId:$keyId lockId:$lockId');
|
|
final LockListInfoEntity entity = await ApiRepository.to.getStarLockInfo(
|
|
keyId: keyId,
|
|
);
|
|
if (entity.errorCode!.codeIsSuccessful &&
|
|
(entity.data?.groupList ?? <GroupList>[]).isNotEmpty) {
|
|
state.lockListInfoGroupEntity.value.groupList ??= <GroupList>[];
|
|
final GroupList list = entity.data!.groupList!.first;
|
|
final LockListInfoItemEntity listItem =
|
|
entity.data!.groupList!.first.lockList!.first;
|
|
final int groupIndex = state.lockListInfoGroupEntity.value.groupList
|
|
?.indexWhere(
|
|
(GroupList group) => group.groupId == list.groupId) ??
|
|
-1;
|
|
if (groupIndex != -1) {
|
|
//已存在
|
|
state.lockListInfoGroupEntity.value.groupList![groupIndex].lockList ??=
|
|
<LockListInfoItemEntity>[];
|
|
final List<LockListInfoItemEntity> lockList = state
|
|
.lockListInfoGroupEntity.value.groupList![groupIndex].lockList!;
|
|
|
|
list.lockList ??= <LockListInfoItemEntity>[];
|
|
final int keyIndex = lockList.indexWhere(
|
|
(LockListInfoItemEntity lock) => lock.lockId == lockId) ??
|
|
-1;
|
|
if (keyIndex != -1) {
|
|
//已存在
|
|
|
|
lockList.removeAt(keyIndex);
|
|
lockList.insert(keyIndex, listItem);
|
|
if (Get.isRegistered<LockDetailLogic>()) {
|
|
final bool isOnlyOneData =
|
|
F.sw(xhjCall: () => false, skyCall: () => lockList.length > 1);
|
|
Get.find<LockDetailLogic>().loadData(
|
|
lockListInfoItemEntity: listItem, isOnlyOneData: isOnlyOneData);
|
|
}
|
|
} else {
|
|
//新增
|
|
lockList.insert(0, listItem);
|
|
}
|
|
} else {
|
|
//新增
|
|
state.lockListInfoGroupEntity.value.groupList!.insert(0, list);
|
|
}
|
|
state.lockListInfoGroupEntity.refresh();
|
|
AppLog.log('刷新调用 loadMainDataLogic');
|
|
loadMainDataLogic(state.lockListInfoGroupEntity.value);
|
|
}
|
|
update();
|
|
}
|
|
|
|
//删除锁设备
|
|
Future<void> deleteStarLockInfo(int keyId, int lockId) async {
|
|
state.lockListInfoGroupEntity.value.groupList
|
|
?.forEach((GroupList groupList) {
|
|
groupList.lockList
|
|
?.removeWhere((LockListInfoItemEntity lock) => lock.keyId == keyId);
|
|
});
|
|
state.lockListInfoGroupEntity.refresh();
|
|
AppLog.log('删除调用 loadMainDataLogic');
|
|
loadMainDataLogic(state.lockListInfoGroupEntity.value);
|
|
if (Get.isRegistered<LockDetailLogic>()) {
|
|
final bool isKey =
|
|
Get.find<LockDetailLogic>().state.keyInfos.value.keyId == keyId;
|
|
if (isKey) {
|
|
//判断当前是否为当前锁
|
|
EasyLoading.showToast('该已锁被删除'.tr, duration: 3.seconds);
|
|
Get.until((Route<dynamic> route) =>
|
|
route.settings.name == Routers.starLockMain);
|
|
}
|
|
}
|
|
update();
|
|
}
|
|
|
|
//初始化订阅
|
|
void _initSubscription() {
|
|
_subscriptions.add(eventBus
|
|
.on<RefreshLockInfoDataEvent>()
|
|
.listen((RefreshLockInfoDataEvent event) {
|
|
//锁设备刷新
|
|
flushedStarLockInfo(
|
|
event.keyId,
|
|
event.lockId,
|
|
);
|
|
}));
|
|
_subscriptions.add(eventBus
|
|
.on<DeleteLockInfoDataEvent>()
|
|
.listen((DeleteLockInfoDataEvent event) {
|
|
//锁设备删除
|
|
deleteStarLockInfo(
|
|
event.keyId,
|
|
event.lockId,
|
|
);
|
|
}));
|
|
_subscriptions.add(eventBus
|
|
.on<RogerThatLockInfoDataEvent>()
|
|
.listen((RogerThatLockInfoDataEvent event) {
|
|
//锁设备新增
|
|
flushedStarLockInfo(
|
|
event.keyId,
|
|
event.lockId,
|
|
);
|
|
}));
|
|
}
|
|
|
|
@override
|
|
Future<void> onReady() async {
|
|
super.onReady();
|
|
//初始化星图服务并绑定配置
|
|
await StartChartManage().init();
|
|
|
|
// 初始化JPush服务并绑定设备ID
|
|
final XSJPushProvider jpushProvider = XSJPushProvider();
|
|
await jpushProvider.initJPushService();
|
|
NotificationService().init(); // 初始化通知服务
|
|
|
|
// 开启UDP
|
|
// AppLog.log('onReady() LockMainLogic');
|
|
// UdpHelp().openUDP();
|
|
BlueManage();
|
|
}
|
|
|
|
@override
|
|
void onInit() {
|
|
super.onInit();
|
|
checkWhetherPushIsEnabled();
|
|
_initSubscription();
|
|
getUserInfoRequest();
|
|
// connectListener();
|
|
// 添加语言变化监听
|
|
listenToLanguageChanges();
|
|
// AppLog.log('onInit() updateZoneOffsetsAndLanguages');
|
|
// updateZoneOffsetsAndLanguages();
|
|
}
|
|
|
|
@override
|
|
void onClose() {
|
|
_subscriptions.forEach((StreamSubscription<void> subscription) {
|
|
subscription.cancel();
|
|
});
|
|
super.onClose();
|
|
}
|
|
|
|
// 监听语言变化并刷新列表
|
|
void listenToLanguageChanges() {
|
|
// 收到切换语言消息，重新拉取一下列表
|
|
eventBus
|
|
.on<ChangeLanguageBlockLastLanguageEvent>()
|
|
.listen((ChangeLanguageBlockLastLanguageEvent event) {
|
|
getStarLockInfo(isUnShowLoading: true);
|
|
});
|
|
}
|
|
|
|
static LockMainLogic? to() {
|
|
if (Get.isRegistered<LockMainLogic>()) {
|
|
return Get.find<LockMainLogic>();
|
|
}
|
|
return null;
|
|
}
|
|
}
|