jiahong
96 KiB
96 KiB
自然写互动课堂平板端应用软件 V1.0
软件著作权鉴别材料 — 源程序
权利人：深圳自然写科技有限公司
版本号：V1.0
源程序目录结构
10-writech-app-pad/
├── main.dart
├── bloc/
│ └── homework_bloc.dart
├── eye_care/
│ └── eye_care_manager.dart
├── renderer/
│ └── stroke_painter.dart
├── repository/
│ └── local_repository.dart
└── service/
├── api_service.dart
└── ble_service.dart
源程序文件清单
（根目录）
main.dart
/// 自然写互动课堂平板端应用软件 V1.0
/// APP入口 - Flutter平板端应用初始化
///
/// 功能说明：
/// 1. 平板端应用初始化（Pad自适应布局配置）
/// 2. 学生端/教师端双模式切换
/// 3. 护眼模式初始化（色温调节、使用时长监控）
/// 4. 全局Bloc状态管理注入
/// 5. 离线模式支持（断网时可继续作答）
import 'dart:async';
import 'dart:io';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
/// 应用入口
void main() async {
WidgetsFlutterBinding.ensureInitialized();
// 全局错误处理
FlutterError.onError = (FlutterErrorDetails details) {
FlutterError.presentError(details);
debugPrint('[CrashReport] ${details.exception}');
};
// 设置系统UI（平板端支持横屏+竖屏）
await SystemChrome.setPreferredOrientations([
DeviceOrientation.portraitUp,
DeviceOrientation.portraitDown,
DeviceOrientation.landscapeLeft,
DeviceOrientation.landscapeRight,
]);
// 初始化全局服务
await _initServices();
runZonedGuarded(() {
runApp(const WritechPadApp());
}, (error, stack) {
debugPrint('[CrashReport] $error\n$stack');
});
}
/// 初始化全局服务
Future<void> _initServices() async {
debugPrint('[App] 服务初始化开始');
// 初始化数据库、网络、BLE、护眼模块
debugPrint('[App] 服务初始化完成');
}
/// 平板端应用根Widget
class WritechPadApp extends StatefulWidget {
const WritechPadApp({super.key});
@override
State<WritechPadApp> createState() => _WritechPadAppState();
}
class _WritechPadAppState extends State<WritechPadApp>
with WidgetsBindingObserver {
/// 当前用户模式（学生/教师）
String _userMode = 'student';
/// 护眼模式是否开启
bool _eyeCareEnabled = false;
/// 色温滤镜值（0.0=正常，1.0=最暖）
double _colorTemperature = 0.0;
@override
void initState() {
super.initState();
WidgetsBinding.instance.addObserver(this);
}
@override
void dispose() {
WidgetsBinding.instance.removeObserver(this);
super.dispose();
}
@override
void didChangeAppLifecycleState(AppLifecycleState state) {
if (state == AppLifecycleState.resumed) {
debugPrint('[App] 应用恢复前台');
} else if (state == AppLifecycleState.paused) {
debugPrint('[App] 应用进入后台');
}
}
@override
Widget build(BuildContext context) {
return MaterialApp(
title: '自然写互动课堂',
debugShowCheckedModeBanner: false,
theme: ThemeData(
useMaterial3: true,
colorScheme: ColorScheme.fromSeed(
seedColor: const Color(0xFF4CAF50),
brightness: Brightness.light,
),
fontFamily: 'NotoSansSC',
),
// 护眼色温滤镜叠加
builder: (context, child) {
if (_eyeCareEnabled && _colorTemperature > 0) {
return ColorFiltered(
colorFilter: ColorFilter.matrix(_buildWarmMatrix(_colorTemperature)),
child: child,
);
}
return child ?? const SizedBox();
},
initialRoute: '/splash',
routes: {
'/splash': (_) => const _SplashPage(),
'/login': (_) => const _LoginPage(),
'/student_home': (_) => const _StudentHomePage(),
'/teacher_home': (_) => const _TeacherHomePage(),
'/homework': (_) => const _HomeworkPage(),
'/practice': (_) => const _PracticePage(),
'/error_book': (_) => const _ErrorBookPage(),
'/settings': (_) => const _SettingsPage(),
},
);
}
/// 构建暖色温矩阵（护眼模式）
List<double> _buildWarmMatrix(double intensity) {
final r = 1.0;
final g = 1.0 - intensity * 0.1;
final b = 1.0 - intensity * 0.3;
return [
r, 0, 0, 0, 0,
0, g, 0, 0, 0,
0, 0, b, 0, 0,
0, 0, 0, 1, 0,
];
}
}
// 占位页面声明
class _SplashPage extends StatelessWidget {
const _SplashPage();
@override
Widget build(BuildContext context) => const Scaffold(body: Center(child: Text('自然写')));
}
class _LoginPage extends StatelessWidget {
const _LoginPage();
@override
Widget build(BuildContext context) => const Scaffold();
}
class _StudentHomePage extends StatelessWidget {
const _StudentHomePage();
@override
Widget build(BuildContext context) => const Scaffold();
}
class _TeacherHomePage extends StatelessWidget {
const _TeacherHomePage();
@override
Widget build(BuildContext context) => const Scaffold();
}
class _HomeworkPage extends StatelessWidget {
const _HomeworkPage();
@override
Widget build(BuildContext context) => const Scaffold();
}
class _PracticePage extends StatelessWidget {
const _PracticePage();
@override
Widget build(BuildContext context) => const Scaffold();
}
class _ErrorBookPage extends StatelessWidget {
const _ErrorBookPage();
@override
Widget build(BuildContext context) => const Scaffold();
}
class _SettingsPage extends StatelessWidget {
const _SettingsPage();
@override
Widget build(BuildContext context) => const Scaffold();
}
bloc/
bloc/homework_bloc.dart
// 自然写互动课堂平板端应用软件 V1.0
// bloc/homework_bloc.dart - 作业状态管理（Bloc模式）
import 'dart:async';
/// 作业状态枚举
enum HomeworkStatus {
/// 待完成
pending,
/// 进行中（已开始作答）
inProgress,
/// 已提交
submitted,
/// 已批改
graded,
/// 已过期
expired,
}
/// 作业数据模型
class HomeworkItem {
final String id;
final String title;
final String subject;
final String teacherName;
final HomeworkStatus status;
final DateTime? assignedAt;
final DateTime? deadline;
final DateTime? submittedAt;
final int? score;
final int totalQuestions;
final int answeredQuestions;
final String? coverImageUrl;
HomeworkItem({
required this.id,
required this.title,
required this.subject,
required this.teacherName,
this.status = HomeworkStatus.pending,
this.assignedAt,
this.deadline,
this.submittedAt,
this.score,
this.totalQuestions = 0,
this.answeredQuestions = 0,
this.coverImageUrl,
});
/// 是否已过截止时间
bool get isOverdue =>
deadline != null && DateTime.now().isAfter(deadline!);
/// 作答进度百分比
double get progress => totalQuestions > 0
? answeredQuestions / totalQuestions
: 0.0;
/// 从JSON解析
factory HomeworkItem.fromJson(Map<String, dynamic> json) {
return HomeworkItem(
id: json['id'] ?? '',
title: json['title'] ?? '',
subject: json['subject'] ?? '',
teacherName: json['teacher_name'] ?? '',
status: _parseStatus(json['status']),
assignedAt: json['assigned_at'] != null
? DateTime.tryParse(json['assigned_at'])
: null,
deadline: json['deadline'] != null
? DateTime.tryParse(json['deadline'])
: null,
submittedAt: json['submitted_at'] != null
? DateTime.tryParse(json['submitted_at'])
: null,
score: json['score'],
totalQuestions: json['total_questions'] ?? 0,
answeredQuestions: json['answered_questions'] ?? 0,
coverImageUrl: json['cover_image_url'],
);
}
/// 解析状态字符串
static HomeworkStatus _parseStatus(String? status) {
switch (status) {
case 'pending':
return HomeworkStatus.pending;
case 'in_progress':
return HomeworkStatus.inProgress;
case 'submitted':
return HomeworkStatus.submitted;
case 'graded':
return HomeworkStatus.graded;
case 'expired':
return HomeworkStatus.expired;
default:
return HomeworkStatus.pending;
}
}
}
/// 作业详情中的题目数据
class HomeworkQuestion {
final String id;
final int index;
final String type;
final String content;
final String? imageUrl;
final List<String>? options;
final String? correctAnswer;
final String? studentAnswer;
final List<Map<String, dynamic>>? studentStrokes;
final int? questionScore;
final int? earnedScore;
final String? teacherComment;
HomeworkQuestion({
required this.id,
required this.index,
required this.type,
required this.content,
this.imageUrl,
this.options,
this.correctAnswer,
this.studentAnswer,
this.studentStrokes,
this.questionScore,
this.earnedScore,
this.teacherComment,
});
/// 从JSON解析
factory HomeworkQuestion.fromJson(Map<String, dynamic> json) {
return HomeworkQuestion(
id: json['id'] ?? '',
index: json['index'] ?? 0,
type: json['type'] ?? 'write',
content: json['content'] ?? '',
imageUrl: json['image_url'],
options: json['options'] != null
? List<String>.from(json['options'])
: null,
correctAnswer: json['correct_answer'],
studentAnswer: json['student_answer'],
studentStrokes: json['student_strokes'] != null
? List<Map<String, dynamic>>.from(json['student_strokes'])
: null,
questionScore: json['question_score'],
earnedScore: json['earned_score'],
teacherComment: json['teacher_comment'],
);
}
}
// ============================================================
// Bloc Events（作业相关事件定义）
// ============================================================
/// 作业事件基类
abstract class HomeworkEvent {}
/// 加载作业列表事件
class LoadHomeworkListEvent extends HomeworkEvent {
final HomeworkStatus? filterStatus;
final int page;
final bool refresh;
LoadHomeworkListEvent({
this.filterStatus,
this.page = 1,
this.refresh = false,
});
}
/// 下载作业详情事件（用于离线作答）
class DownloadHomeworkEvent extends HomeworkEvent {
final String homeworkId;
DownloadHomeworkEvent(this.homeworkId);
}
/// 保存作答进度事件（本地暂存）
class SaveAnswerProgressEvent extends HomeworkEvent {
final String homeworkId;
final String questionId;
final String? textAnswer;
final List<Map<String, dynamic>>? strokeData;
SaveAnswerProgressEvent({
required this.homeworkId,
required this.questionId,
this.textAnswer,
this.strokeData,
});
}
/// 提交作业事件
class SubmitHomeworkEvent extends HomeworkEvent {
final String homeworkId;
SubmitHomeworkEvent(this.homeworkId);
}
/// 查看批改结果事件
class ViewGradeResultEvent extends HomeworkEvent {
final String homeworkId;
ViewGradeResultEvent(this.homeworkId);
}
// ============================================================
// Bloc States（作业相关状态定义）
// ============================================================
/// 作业状态基类
abstract class HomeworkState {}
/// 初始状态
class HomeworkInitialState extends HomeworkState {}
/// 加载中状态
class HomeworkLoadingState extends HomeworkState {
final String? message;
HomeworkLoadingState({this.message});
}
/// 作业列表加载成功状态
class HomeworkListLoadedState extends HomeworkState {
final List<HomeworkItem> homeworks;
final bool hasMore;
final int currentPage;
final HomeworkStatus? currentFilter;
/// 各状态的作业计数统计
final Map<HomeworkStatus, int> statusCounts;
HomeworkListLoadedState({
required this.homeworks,
this.hasMore = false,
this.currentPage = 1,
this.currentFilter,
this.statusCounts = const {},
});
}
/// 作业详情加载成功状态
class HomeworkDetailLoadedState extends HomeworkState {
final HomeworkItem homework;
final List<HomeworkQuestion> questions;
final bool isOfflineAvailable;
HomeworkDetailLoadedState({
required this.homework,
required this.questions,
this.isOfflineAvailable = false,
});
}
/// 作答进度保存成功状态
class AnswerSavedState extends HomeworkState {
final String homeworkId;
final String questionId;
final int answeredCount;
final int totalCount;
AnswerSavedState({
required this.homeworkId,
required this.questionId,
required this.answeredCount,
required this.totalCount,
});
}
/// 作业提交成功状态
class HomeworkSubmittedState extends HomeworkState {
final String homeworkId;
final DateTime submittedAt;
HomeworkSubmittedState({
required this.homeworkId,
required this.submittedAt,
});
}
/// 批改结果状态
class GradeResultState extends HomeworkState {
final HomeworkItem homework;
final List<HomeworkQuestion> questions;
final int totalScore;
final int earnedScore;
final String? overallComment;
GradeResultState({
required this.homework,
required this.questions,
required this.totalScore,
required this.earnedScore,
this.overallComment,
});
}
/// 错误状态
class HomeworkErrorState extends HomeworkState {
final String message;
final String? actionType;
HomeworkErrorState({
required this.message,
this.actionType,
});
}
// ============================================================
// HomeworkBloc 实现
// ============================================================
/// 作业状态管理Bloc
/// 管理作业列表加载、下载、作答、提交、查看批改结果等完整流程
class HomeworkBloc {
/// 当前状态
HomeworkState _state = HomeworkInitialState();
/// 状态流控制器
final StreamController<HomeworkState> _stateController =
StreamController<HomeworkState>.broadcast();
/// 本地缓存的作业列表
List<HomeworkItem> _cachedHomeworks = [];
/// 本地缓存的作答进度 {homeworkId: {questionId: answerData}}
final Map<String, Map<String, dynamic>> _answerCache = {};
/// 获取当前状态
HomeworkState get state => _state;
/// 状态流
Stream<HomeworkState> get stateStream => _stateController.stream;
/// 发射新状态
void _emit(HomeworkState newState) {
_state = newState;
_stateController.add(newState);
}
/// 处理事件分发
void add(HomeworkEvent event) {
if (event is LoadHomeworkListEvent) {
_handleLoadList(event);
} else if (event is DownloadHomeworkEvent) {
_handleDownload(event);
} else if (event is SaveAnswerProgressEvent) {
_handleSaveAnswer(event);
} else if (event is SubmitHomeworkEvent) {
_handleSubmit(event);
} else if (event is ViewGradeResultEvent) {
_handleViewGrade(event);
}
}
/// 处理加载作业列表
Future<void> _handleLoadList(LoadHomeworkListEvent event) async {
try {
_emit(HomeworkLoadingState(message: '正在加载作业列表...'));
// 调用API获取作业列表
// final response = await PadApiService.instance.getHomeworkList(
// page: event.page,
// status: event.filterStatus?.name,
// );
// 模拟数据处理逻辑
if (event.refresh) {
_cachedHomeworks.clear();
}
// 统计各状态作业数量
final statusCounts = <HomeworkStatus, int>{};
for (final hw in _cachedHomeworks) {
statusCounts[hw.status] = (statusCounts[hw.status] ?? 0) + 1;
}
// 根据筛选条件过滤
List<HomeworkItem> filtered = _cachedHomeworks;
if (event.filterStatus != null) {
filtered = _cachedHomeworks
.where((hw) => hw.status == event.filterStatus)
.toList();
}
_emit(HomeworkListLoadedState(
homeworks: filtered,
hasMore: false,
currentPage: event.page,
currentFilter: event.filterStatus,
statusCounts: statusCounts,
));
} catch (e) {
_emit(HomeworkErrorState(
message: '加载作业列表失败: $e',
actionType: 'load_list',
));
}
}
/// 处理下载作业详情（支持离线作答）
Future<void> _handleDownload(DownloadHomeworkEvent event) async {
try {
_emit(HomeworkLoadingState(message: '正在下载作业内容...'));
// 调用API下载作业详情
// final response = await PadApiService.instance.downloadHomework(
// event.homeworkId,
// );
// 将作业内容缓存到本地SQLite（支持离线作答）
// await LocalRepository.instance.cacheHomework(...)
// _emit(HomeworkDetailLoadedState(...));
} catch (e) {
_emit(HomeworkErrorState(
message: '下载作业失败: $e',
actionType: 'download',
));
}
}
/// 处理保存作答进度（本地暂存，支持断点续答）
Future<void> _handleSaveAnswer(SaveAnswerProgressEvent event) async {
try {
// 更新内存缓存
_answerCache.putIfAbsent(event.homeworkId, () => {});
_answerCache[event.homeworkId]![event.questionId] = {
'text_answer': event.textAnswer,
'stroke_data': event.strokeData,
'saved_at': DateTime.now().toIso8601String(),
};
// 持久化到本地数据库
// await LocalRepository.instance.saveAnswerProgress(...)
// 计算已作答题目数
final answeredCount = _answerCache[event.homeworkId]?.length ?? 0;
_emit(AnswerSavedState(
homeworkId: event.homeworkId,
questionId: event.questionId,
answeredCount: answeredCount,
totalCount: 0, // 从缓存的作业详情中获取
));
} catch (e) {
_emit(HomeworkErrorState(
message: '保存作答进度失败: $e',
actionType: 'save_answer',
));
}
}
/// 处理提交作业
Future<void> _handleSubmit(SubmitHomeworkEvent event) async {
try {
_emit(HomeworkLoadingState(message: '正在提交作业...'));
// 收集所有作答数据
final answers = _answerCache[event.homeworkId] ?? {};
// 构建提交数据（含笔迹页面数据）
final strokePages = answers.entries.map((entry) {
return {
'question_id': entry.key,
'answer': entry.value,
};
}).toList();
// 调用API提交
// final response = await PadApiService.instance.submitHomework(
// homeworkId: event.homeworkId,
// strokePages: strokePages,
// );
// 提交成功后清除本地缓存
_answerCache.remove(event.homeworkId);
_emit(HomeworkSubmittedState(
homeworkId: event.homeworkId,
submittedAt: DateTime.now(),
));
} catch (e) {
_emit(HomeworkErrorState(
message: '提交作业失败: $e',
actionType: 'submit',
));
}
}
/// 处理查看批改结果
Future<void> _handleViewGrade(ViewGradeResultEvent event) async {
try {
_emit(HomeworkLoadingState(message: '正在加载批改结果...'));
// 调用API获取批改结果
// final response = await PadApiService.instance.getHomeworkResult(
// event.homeworkId,
// );
// _emit(GradeResultState(...));
} catch (e) {
_emit(HomeworkErrorState(
message: '加载批改结果失败: $e',
actionType: 'view_grade',
));
}
}
/// 释放资源
void dispose() {
_stateController.close();
_cachedHomeworks.clear();
_answerCache.clear();
}
}
eye_care/
eye_care/eye_care_manager.dart
/// 自然写互动课堂平板端应用软件 V1.0
/// 护眼管理器 - 色温调节、使用时长监控、距离检测
///
/// 功能说明：
/// 1. 色温调节（暖色滤镜，减少蓝光对眼睛的刺激）
/// 2. 使用时长监控（按应用/科目统计，超时提醒休息）
/// 3. 距离检测（前置摄像头检测用眼距离，过近时提醒）
/// 4. 定时提醒（每30分钟提醒休息，远眺放松）
/// 5. 家长远程管控（接收家长设置的时段/时长限制）
/// 6. 护眼数据统计（每日使用时长报告）
import 'dart:async';
/// 护眼模式配置
class EyeCareConfig {
/// 是否启用护眼模式
bool enabled;
/// 色温强度（0.0=关闭, 1.0=最暖）
double colorTemperature;
/// 连续使用提醒间隔（分钟）
int reminderIntervalMinutes;
/// 每日使用时长上限（分钟，0=不限制）
int dailyLimitMinutes;
/// 允许使用的时段（开始小时, 结束小时）
int allowedStartHour;
int allowedEndHour;
/// 是否启用距离检测
bool distanceDetectionEnabled;
/// 安全用眼距离（厘米）
int safeDistanceCm;
/// 夜间模式自动开启时间（小时）
int nightModeStartHour;
int nightModeEndHour;
EyeCareConfig({
this.enabled = true,
this.colorTemperature = 0.3,
this.reminderIntervalMinutes = 30,
this.dailyLimitMinutes = 120,
this.allowedStartHour = 7,
this.allowedEndHour = 21,
this.distanceDetectionEnabled = false,
this.safeDistanceCm = 30,
this.nightModeStartHour = 20,
this.nightModeEndHour = 7,
});
Map<String, dynamic> toJson() => {
'enabled': enabled,
'color_temperature': colorTemperature,
'reminder_interval': reminderIntervalMinutes,
'daily_limit': dailyLimitMinutes,
'allowed_start': allowedStartHour,
'allowed_end': allowedEndHour,
'distance_enabled': distanceDetectionEnabled,
'safe_distance': safeDistanceCm,
'night_start': nightModeStartHour,
'night_end': nightModeEndHour,
};
factory EyeCareConfig.fromJson(Map<String, dynamic> json) {
return EyeCareConfig(
enabled: json['enabled'] ?? true,
colorTemperature: (json['color_temperature'] ?? 0.3).toDouble(),
reminderIntervalMinutes: json['reminder_interval'] ?? 30,
dailyLimitMinutes: json['daily_limit'] ?? 120,
allowedStartHour: json['allowed_start'] ?? 7,
allowedEndHour: json['allowed_end'] ?? 21,
distanceDetectionEnabled: json['distance_enabled'] ?? false,
safeDistanceCm: json['safe_distance'] ?? 30,
nightModeStartHour: json['night_start'] ?? 20,
nightModeEndHour: json['night_end'] ?? 7,
);
}
}
/// 使用时长记录
class UsageRecord {
final String date; // 日期 (yyyy-MM-dd)
final String category; // 分类 (homework/practice/reading)
final int durationMinutes; // 使用时长（分钟）
final int sessionCount; // 使用次数
UsageRecord({
required this.date,
required this.category,
required this.durationMinutes,
required this.sessionCount,
});
Map<String, dynamic> toJson() => {
'date': date, 'category': category,
'duration': durationMinutes, 'sessions': sessionCount,
};
}
/// 护眼事件类型
enum EyeCareEvent {
restReminder, // 休息提醒
dailyLimitReached, // 每日时长上限
outsideAllowedTime, // 超出允许使用时段
tooCloseWarning, // 用眼距离过近
nightModeOn, // 夜间模式开启
nightModeOff, // 夜间模式关闭
}
/// 护眼事件回调
typedef EyeCareEventCallback = void Function(EyeCareEvent event, Map<String, dynamic> data);
/// 护眼管理器
class EyeCareManager {
/// 护眼配置
EyeCareConfig _config = EyeCareConfig();
/// 事件回调列表
final List<EyeCareEventCallback> _callbacks = [];
/// 当前会话开始时间
DateTime? _sessionStartTime;
/// 今日累计使用时长（秒）
int _todayUsageSeconds = 0;
/// 当前连续使用时长（秒）
int _continuousUsageSeconds = 0;
/// 今日使用记录
final Map<String, int> _categoryUsage = {};
/// 计时器（每秒更新使用时长）
Timer? _usageTimer;
/// 距离检测计时器
Timer? _distanceTimer;
/// 夜间模式检查计时器
Timer? _nightModeTimer;
/// 当前是否在夜间模式
bool _isNightMode = false;
/// 当前色温值（供外部读取）
double get currentColorTemperature {
if (!_config.enabled) return 0.0;
if (_isNightMode) return _config.colorTemperature * 1.5; // 夜间加强
return _config.colorTemperature;
}
/// 今日总使用时长（分钟）
int get todayUsageMinutes => _todayUsageSeconds ~/ 60;
/// 剩余可用时长（分钟，-1表示不限制）
int get remainingMinutes {
if (_config.dailyLimitMinutes <= 0) return -1;
return _config.dailyLimitMinutes - todayUsageMinutes;
}
/// 注册事件回调
void addCallback(EyeCareEventCallback callback) {
_callbacks.add(callback);
}
/// 移除事件回调
void removeCallback(EyeCareEventCallback callback) {
_callbacks.remove(callback);
}
/// 更新配置（家长远程设置后调用）
void updateConfig(EyeCareConfig newConfig) {
_config = newConfig;
if (_config.enabled) {
_startMonitoring();
} else {
_stopMonitoring();
}
}
/// 开始使用（进入学习功能时调用）
void startSession({String category = 'default'}) {
_sessionStartTime = DateTime.now();
_continuousUsageSeconds = 0;
// 检查是否在允许时段内
final now = DateTime.now();
if (_config.enabled && !_isWithinAllowedTime(now)) {
_notifyEvent(EyeCareEvent.outsideAllowedTime, {
'allowed_start': _config.allowedStartHour,
'allowed_end': _config.allowedEndHour,
});
}
// 启动使用时长计时器
_usageTimer?.cancel();
_usageTimer = Timer.periodic(const Duration(seconds: 1), (_) {
_todayUsageSeconds++;
_continuousUsageSeconds++;
// 检查连续使用时长提醒
if (_config.reminderIntervalMinutes > 0 &&
_continuousUsageSeconds > 0 &&
_continuousUsageSeconds % (_config.reminderIntervalMinutes * 60) == 0) {
_notifyEvent(EyeCareEvent.restReminder, {
'continuous_minutes': _continuousUsageSeconds ~/ 60,
'total_minutes': todayUsageMinutes,
});
}
// 检查每日使用上限
if (_config.dailyLimitMinutes > 0 &&
todayUsageMinutes >= _config.dailyLimitMinutes) {
_notifyEvent(EyeCareEvent.dailyLimitReached, {
'limit_minutes': _config.dailyLimitMinutes,
'used_minutes': todayUsageMinutes,
});
}
});
// 启动距离检测
if (_config.distanceDetectionEnabled) {
_startDistanceDetection();
}
// 启动夜间模式检查
_startNightModeCheck();
}
/// 结束使用（退出学习功能时调用）
void endSession({String category = 'default'}) {
_usageTimer?.cancel();
_usageTimer = null;
if (_sessionStartTime != null) {
final duration = DateTime.now().difference(_sessionStartTime!).inMinutes;
_categoryUsage[category] = (_categoryUsage[category] ?? 0) + duration;
}
_sessionStartTime = null;
_continuousUsageSeconds = 0;
_distanceTimer?.cancel();
_distanceTimer = null;
}
/// 用户休息后重置连续使用计时
void acknowledgeRest() {
_continuousUsageSeconds = 0;
}
/// 检查当前时间是否在允许使用时段内
bool _isWithinAllowedTime(DateTime time) {
final hour = time.hour;
if (_config.allowedStartHour <= _config.allowedEndHour) {
return hour >= _config.allowedStartHour && hour < _config.allowedEndHour;
} else {
// 跨午夜的情况
return hour >= _config.allowedStartHour || hour < _config.allowedEndHour;
}
}
/// 启动监控
void _startMonitoring() {
_startNightModeCheck();
}
/// 停止监控
void _stopMonitoring() {
_usageTimer?.cancel();
_distanceTimer?.cancel();
_nightModeTimer?.cancel();
}
/// 启动距离检测（通过前置摄像头估算用眼距离）
void _startDistanceDetection() {
_distanceTimer?.cancel();
_distanceTimer = Timer.periodic(const Duration(seconds: 10), (_) {
// 调用前置摄像头进行人脸检测
// 通过人脸框大小估算距离（人脸越大=距离越近）
_checkEyeDistance();
});
}
/// 检查用眼距离（基于前置摄像头人脸检测）
void _checkEyeDistance() {
// 实际实现：
// 1. 使用CameraController获取前置摄像头预览帧
// 2. 使用MLKit/TFLite进行人脸检测
// 3. 根据人脸框宽度估算距离: distance = (focal_length * real_face_width) / face_width_in_pixels
// 4. 本地处理，不上传图像数据（隐私保护）
// 模拟距离检测结果
final estimatedDistanceCm = 35; // 实际从摄像头计算
if (estimatedDistanceCm < _config.safeDistanceCm) {
_notifyEvent(EyeCareEvent.tooCloseWarning, {
'current_distance': estimatedDistanceCm,
'safe_distance': _config.safeDistanceCm,
});
}
}
/// 启动夜间模式检查
void _startNightModeCheck() {
_nightModeTimer?.cancel();
_nightModeTimer = Timer.periodic(const Duration(minutes: 1), (_) {
final hour = DateTime.now().hour;
final shouldBeNightMode = _isNightTimeHour(hour);
if (shouldBeNightMode && !_isNightMode) {
_isNightMode = true;
_notifyEvent(EyeCareEvent.nightModeOn, {});
} else if (!shouldBeNightMode && _isNightMode) {
_isNightMode = false;
_notifyEvent(EyeCareEvent.nightModeOff, {});
}
});
// 立即检查一次
final hour = DateTime.now().hour;
_isNightMode = _isNightTimeHour(hour);
}
/// 判断是否为夜间时段
bool _isNightTimeHour(int hour) {
if (_config.nightModeStartHour <= _config.nightModeEndHour) {
return hour >= _config.nightModeStartHour && hour < _config.nightModeEndHour;
} else {
return hour >= _config.nightModeStartHour || hour < _config.nightModeEndHour;
}
}
/// 获取今日使用统计
List<UsageRecord> getTodayUsageRecords() {
final today = DateTime.now().toString().substring(0, 10);
return _categoryUsage.entries.map((e) => UsageRecord(
date: today,
category: e.key,
durationMinutes: e.value,
sessionCount: 1,
)).toList();
}
/// 通知事件到所有回调
void _notifyEvent(EyeCareEvent event, Map<String, dynamic> data) {
for (final callback in _callbacks) {
try {
callback(event, data);
} catch (e) {
// 忽略回调异常
}
}
}
/// 释放资源
void dispose() {
_usageTimer?.cancel();
_distanceTimer?.cancel();
_nightModeTimer?.cancel();
_callbacks.clear();
}
}
renderer/
renderer/stroke_painter.dart
/// 自然写互动课堂平板端应用软件 V1.0
/// Skia笔迹渲染器 - CustomPainter实现触屏直写与点阵笔笔迹渲染
///
/// 功能说明：
/// 1. CustomPainter高性能笔迹绘制（Skia引擎）
/// 2. 触屏直写支持（手指/触控笔Pointer事件处理）
/// 3. 点阵笔BLE数据渲染（从BLE服务接收坐标数据）
/// 4. 压力感应笔锋效果（触控笔ActiveStylus压力数据）
/// 5. 贝塞尔曲线平滑算法
/// 6. 字帖练习辅助线（田字格/米字格/四线三格）
/// 7. 撤销/重做操作栈
/// 8. 笔迹导出（SVG/PNG格式）
import 'dart:math';
import 'dart:ui' as ui;
import 'package:flutter/material.dart';
import 'package:flutter/gestures.dart';
/* ========== 数据模型 ========== */
/// 笔迹点
class PadStrokePoint {
final double x;
final double y;
final double pressure;
final int timestamp;
const PadStrokePoint({
required this.x,
required this.y,
this.pressure = 0.5,
required this.timestamp,
});
Map<String, dynamic> toJson() => {
'x': x, 'y': y, 'pressure': pressure, 'timestamp': timestamp,
};
}
/// 笔画
class PadStroke {
final List<PadStrokePoint> points;
final Color color;
final double baseWidth;
final String source; // 'touch'=触屏, 'ble'=点阵笔
PadStroke({
List<PadStrokePoint>? points,
this.color = Colors.black,
this.baseWidth = 2.5,
this.source = 'touch',
}) : points = points ?? [];
void addPoint(PadStrokePoint point) => points.add(point);
}
/// 辅助线类型
enum GuideLineType {
none, // 无辅助线
tianZiGe, // 田字格
miZiGe, // 米字格
siXianSanGe, // 四线三格（英文/拼音）
}
/// 撤销/重做操作
sealed class CanvasAction {}
class AddStrokeAction extends CanvasAction {
final PadStroke stroke;
AddStrokeAction(this.stroke);
}
class ClearAction extends CanvasAction {
final List<PadStroke> clearedStrokes;
ClearAction(this.clearedStrokes);
}
/* ========== 笔迹画布Widget ========== */
/// 平板端笔迹渲染画布
/// 支持触屏直写和BLE点阵笔两种输入方式
class PadStrokeCanvas extends StatefulWidget {
/// 初始笔画数据（如加载已有作业笔迹）
final List<PadStroke>? initialStrokes;
/// 辅助线类型
final GuideLineType guideLineType;
/// 是否只读模式（查看已提交的作业）
final bool readOnly;
/// 笔迹颜色
final Color strokeColor;
/// 笔画宽度
final double strokeWidth;
/// 笔迹变化回调
final Function(List<PadStroke>)? onStrokesChanged;
const PadStrokeCanvas({
super.key,
this.initialStrokes,
this.guideLineType = GuideLineType.none,
this.readOnly = false,
this.strokeColor = Colors.black,
this.strokeWidth = 2.5,
this.onStrokesChanged,
});
@override
State<PadStrokeCanvas> createState() => _PadStrokeCanvasState();
}
class _PadStrokeCanvasState extends State<PadStrokeCanvas> {
/// 已完成的笔画列表
final List<PadStroke> _strokes = [];
/// 当前正在绘制的笔画
PadStroke? _currentStroke;
/// 撤销栈
final List<CanvasAction> _undoStack = [];
/// 重做栈
final List<CanvasAction> _redoStack = [];
/// 最大撤销步数
static const int maxUndoSteps = 50;
@override
void initState() {
super.initState();
if (widget.initialStrokes != null) {
_strokes.addAll(widget.initialStrokes!);
}
}
/// 撤销最后一个操作
void undo() {
if (_undoStack.isEmpty) return;
final action = _undoStack.removeLast();
if (action is AddStrokeAction) {
_strokes.remove(action.stroke);
_redoStack.add(action);
} else if (action is ClearAction) {
_strokes.addAll(action.clearedStrokes);
_redoStack.add(action);
}
setState(() {});
widget.onStrokesChanged?.call(_strokes);
}
/// 重做上一个撤销的操作
void redo() {
if (_redoStack.isEmpty) return;
final action = _redoStack.removeLast();
if (action is AddStrokeAction) {
_strokes.add(action.stroke);
_undoStack.add(action);
} else if (action is ClearAction) {
_strokes.clear();
_undoStack.add(action);
}
setState(() {});
widget.onStrokesChanged?.call(_strokes);
}
/// 清除所有笔迹
void clearAll() {
if (_strokes.isEmpty) return;
final cleared = List<PadStroke>.from(_strokes);
_undoStack.add(ClearAction(cleared));
_strokes.clear();
_redoStack.clear();
setState(() {});
widget.onStrokesChanged?.call(_strokes);
}
/// 从BLE点阵笔添加笔画（外部调用）
void addBleStroke(PadStroke stroke) {
_strokes.add(stroke);
_undoStack.add(AddStrokeAction(stroke));
_redoStack.clear();
setState(() {});
widget.onStrokesChanged?.call(_strokes);
}
/// 获取所有笔画数据（用于提交）
List<PadStroke> getStrokes() => List.unmodifiable(_strokes);
@override
Widget build(BuildContext context) {
return Listener(
// 使用Listener而非GestureDetector，以获取精确的Pointer事件
onPointerDown: widget.readOnly ? null : _onPointerDown,
onPointerMove: widget.readOnly ? null : _onPointerMove,
onPointerUp: widget.readOnly ? null : _onPointerUp,
child: ClipRect(
child: CustomPaint(
painter: _PadStrokePainter(
strokes: _strokes,
currentStroke: _currentStroke,
guideLineType: widget.guideLineType,
),
size: Size.infinite,
),
),
);
}
/// 触屏落笔
void _onPointerDown(PointerDownEvent event) {
final pressure = event.pressure > 0 ? event.pressure : 0.5;
_currentStroke = PadStroke(
color: widget.strokeColor,
baseWidth: widget.strokeWidth,
source: event.kind == PointerDeviceKind.stylus ? 'stylus' : 'touch',
);
_currentStroke!.addPoint(PadStrokePoint(
x: event.localPosition.dx,
y: event.localPosition.dy,
pressure: pressure,
timestamp: DateTime.now().millisecondsSinceEpoch,
));
setState(() {});
}
/// 触屏移动
void _onPointerMove(PointerMoveEvent event) {
if (_currentStroke == null) return;
final pressure = event.pressure > 0 ? event.pressure : 0.5;
_currentStroke!.addPoint(PadStrokePoint(
x: event.localPosition.dx,
y: event.localPosition.dy,
pressure: pressure,
timestamp: DateTime.now().millisecondsSinceEpoch,
));
setState(() {});
}
/// 触屏抬笔
void _onPointerUp(PointerUpEvent event) {
if (_currentStroke == null) return;
if (_currentStroke!.points.length >= 2) {
_strokes.add(_currentStroke!);
_undoStack.add(AddStrokeAction(_currentStroke!));
_redoStack.clear();
// 限制撤销栈大小
if (_undoStack.length > maxUndoSteps) {
_undoStack.removeAt(0);
}
widget.onStrokesChanged?.call(_strokes);
}
_currentStroke = null;
setState(() {});
}
}
/* ========== Painter实现 ========== */
/// 笔迹绘制Painter
class _PadStrokePainter extends CustomPainter {
final List<PadStroke> strokes;
final PadStroke? currentStroke;
final GuideLineType guideLineType;
_PadStrokePainter({
required this.strokes,
this.currentStroke,
this.guideLineType = GuideLineType.none,
});
@override
void paint(Canvas canvas, Size size) {
// 绘制背景
canvas.drawRect(
Rect.fromLTWH(0, 0, size.width, size.height),
Paint()..color = Colors.white,
);
// 绘制辅助线
if (guideLineType != GuideLineType.none) {
_drawGuideLines(canvas, size);
}
// 绘制已完成的笔画
for (final stroke in strokes) {
_drawStroke(canvas, stroke);
}
// 绘制当前活跃笔画
if (currentStroke != null) {
_drawStroke(canvas, currentStroke!);
}
}
/// 绘制辅助线
void _drawGuideLines(Canvas canvas, Size size) {
final paint = Paint()
..style = PaintingStyle.stroke
..strokeWidth = 0.5;
switch (guideLineType) {
case GuideLineType.tianZiGe:
_drawTianZiGe(canvas, size, paint);
break;
case GuideLineType.miZiGe:
_drawMiZiGe(canvas, size, paint);
break;
case GuideLineType.siXianSanGe:
_drawSiXianSanGe(canvas, size, paint);
break;
default:
break;
}
}
/// 绘制田字格
void _drawTianZiGe(Canvas canvas, Size size, Paint paint) {
const cellSize = 80.0;
paint.color = Colors.red.withValues(alpha: 0.3);
// 外框（实线）
for (double x = 0; x <= size.width; x += cellSize) {
canvas.drawLine(Offset(x, 0), Offset(x, size.height), paint);
}
for (double y = 0; y <= size.height; y += cellSize) {
canvas.drawLine(Offset(0, y), Offset(size.width, y), paint);
}
// 中心十字线（虚线效果用半透明）
paint.color = Colors.red.withValues(alpha: 0.15);
final halfCell = cellSize / 2;
for (double x = halfCell; x < size.width; x += cellSize) {
canvas.drawLine(Offset(x, 0), Offset(x, size.height), paint);
}
for (double y = halfCell; y < size.height; y += cellSize) {
canvas.drawLine(Offset(0, y), Offset(size.width, y), paint);
}
}
/// 绘制米字格
void _drawMiZiGe(Canvas canvas, Size size, Paint paint) {
const cellSize = 80.0;
paint.color = Colors.red.withValues(alpha: 0.3);
for (double x = 0; x <= size.width; x += cellSize) {
canvas.drawLine(Offset(x, 0), Offset(x, size.height), paint);
}
for (double y = 0; y <= size.height; y += cellSize) {
canvas.drawLine(Offset(0, y), Offset(size.width, y), paint);
}
// 对角线 + 十字线
paint.color = Colors.red.withValues(alpha: 0.15);
for (double x = 0; x < size.width; x += cellSize) {
for (double y = 0; y < size.height; y += cellSize) {
// 对角线
canvas.drawLine(Offset(x, y), Offset(x + cellSize, y + cellSize), paint);
canvas.drawLine(Offset(x + cellSize, y), Offset(x, y + cellSize), paint);
// 十字线
canvas.drawLine(Offset(x + cellSize / 2, y), Offset(x + cellSize / 2, y + cellSize), paint);
canvas.drawLine(Offset(x, y + cellSize / 2), Offset(x + cellSize, y + cellSize / 2), paint);
}
}
}
/// 绘制四线三格（拼音/英文）
void _drawSiXianSanGe(Canvas canvas, Size size, Paint paint) {
const lineSpacing = 15.0;
const groupHeight = lineSpacing * 3;
const groupGap = 20.0;
paint.color = Colors.green.withValues(alpha: 0.3);
double y = 20;
while (y < size.height - groupHeight) {
// 四条横线
for (int i = 0; i < 4; i++) {
final lineY = y + i * lineSpacing;
// 第二条线（中线）用虚线表示
if (i == 1 || i == 2) {
paint.color = Colors.green.withValues(alpha: 0.15);
} else {
paint.color = Colors.green.withValues(alpha: 0.3);
}
canvas.drawLine(Offset(0, lineY), Offset(size.width, lineY), paint);
}
y += groupHeight + groupGap;
}
}
/// 绘制单个笔画（贝塞尔平滑 + 压力笔锋）
void _drawStroke(Canvas canvas, PadStroke stroke) {
if (stroke.points.length < 2) return;
final paint = Paint()
..color = stroke.color
..strokeCap = StrokeCap.round
..strokeJoin = StrokeJoin.round
..style = PaintingStyle.stroke
..isAntiAlias = true;
for (int i = 1; i < stroke.points.length; i++) {
final prev = stroke.points[i - 1];
final curr = stroke.points[i];
// 压力笔锋宽度计算
final avgPressure = (prev.pressure + curr.pressure) / 2.0;
var width = stroke.baseWidth * (0.3 + avgPressure * 1.7);
// 落笔过渡
if (i < 5) width *= (i / 5.0);
// 抬笔过渡
final remaining = stroke.points.length - i;
if (remaining < 5) width *= (remaining / 5.0);
width = max(width, 0.5);
paint.strokeWidth = width;
if (i >= 2) {
// 贝塞尔曲线平滑
final pp = stroke.points[i - 2];
final cp1x = prev.x + (curr.x - pp.x) * 0.2;
final cp1y = prev.y + (curr.y - pp.y) * 0.2;
final cp2x = curr.x - (curr.x - prev.x) * 0.2;
final cp2y = curr.y - (curr.y - prev.y) * 0.2;
final path = Path()
..moveTo(prev.x, prev.y)
..cubicTo(cp1x, cp1y, cp2x, cp2y, curr.x, curr.y);
canvas.drawPath(path, paint);
} else {
canvas.drawLine(Offset(prev.x, prev.y), Offset(curr.x, curr.y), paint);
}
}
}
@override
bool shouldRepaint(covariant _PadStrokePainter oldDelegate) {
return oldDelegate.strokes.length != strokes.length ||
oldDelegate.currentStroke != currentStroke;
}
}
repository/
repository/local_repository.dart
// 自然写互动课堂平板端应用软件 V1.0
// repository/local_repository.dart - SQLite + Hive本地数据存储
import 'dart:async';
import 'dart:convert';
/// 数据库表名常量
class PadDbTables {
static const String homework = 'pad_homework';
static const String homeworkQuestion = 'pad_homework_question';
static const String answerProgress = 'pad_answer_progress';
static const String errorBook = 'pad_error_book';
static const String studyPlan = 'pad_study_plan';
static const String studyTask = 'pad_study_task';
static const String practiceRecord = 'pad_practice_record';
static const String strokeCache = 'pad_stroke_cache';
static const String offlineAction = 'pad_offline_action';
static const String usageRecord = 'pad_usage_record';
}
/// 数据库版本
const int padDbVersion = 4;
/// 作业缓存模型
class CachedHomework {
final String id;
final String title;
final String subject;
final String teacherName;
final String status;
final String? deadline;
final String? content;
final int totalQuestions;
final int answeredQuestions;
final DateTime cachedAt;
CachedHomework({
required this.id,
required this.title,
required this.subject,
required this.teacherName,
required this.status,
this.deadline,
this.content,
this.totalQuestions = 0,
this.answeredQuestions = 0,
required this.cachedAt,
});
Map<String, dynamic> toMap() => {
'id': id,
'title': title,
'subject': subject,
'teacher_name': teacherName,
'status': status,
'deadline': deadline,
'content': content,
'total_questions': totalQuestions,
'answered_questions': answeredQuestions,
'cached_at': cachedAt.toIso8601String(),
};
factory CachedHomework.fromMap(Map<String, dynamic> map) {
return CachedHomework(
id: map['id'],
title: map['title'] ?? '',
subject: map['subject'] ?? '',
teacherName: map['teacher_name'] ?? '',
status: map['status'] ?? 'pending',
deadline: map['deadline'],
content: map['content'],
totalQuestions: map['total_questions'] ?? 0,
answeredQuestions: map['answered_questions'] ?? 0,
cachedAt: DateTime.parse(map['cached_at']),
);
}
}
/// 错题记录模型
class ErrorBookEntry {
final String id;
final String homeworkId;
final String questionId;
final String subject;
final String? knowledgePoint;
final String questionContent;
final String? questionImageUrl;
final String? studentAnswer;
final String? correctAnswer;
final String? errorReason;
final int reviewCount;
final DateTime createdAt;
final DateTime? lastReviewAt;
ErrorBookEntry({
required this.id,
required this.homeworkId,
required this.questionId,
required this.subject,
this.knowledgePoint,
required this.questionContent,
this.questionImageUrl,
this.studentAnswer,
this.correctAnswer,
this.errorReason,
this.reviewCount = 0,
required this.createdAt,
this.lastReviewAt,
});
Map<String, dynamic> toMap() => {
'id': id,
'homework_id': homeworkId,
'question_id': questionId,
'subject': subject,
'knowledge_point': knowledgePoint,
'question_content': questionContent,
'question_image_url': questionImageUrl,
'student_answer': studentAnswer,
'correct_answer': correctAnswer,
'error_reason': errorReason,
'review_count': reviewCount,
'created_at': createdAt.toIso8601String(),
'last_review_at': lastReviewAt?.toIso8601String(),
};
factory ErrorBookEntry.fromMap(Map<String, dynamic> map) {
return ErrorBookEntry(
id: map['id'],
homeworkId: map['homework_id'] ?? '',
questionId: map['question_id'] ?? '',
subject: map['subject'] ?? '',
knowledgePoint: map['knowledge_point'],
questionContent: map['question_content'] ?? '',
questionImageUrl: map['question_image_url'],
studentAnswer: map['student_answer'],
correctAnswer: map['correct_answer'],
errorReason: map['error_reason'],
reviewCount: map['review_count'] ?? 0,
createdAt: DateTime.parse(map['created_at']),
lastReviewAt: map['last_review_at'] != null
? DateTime.parse(map['last_review_at'])
: null,
);
}
}
/// 学习计划模型
class StudyPlanEntry {
final String id;
final String title;
final String type;
final String? subject;
final DateTime startDate;
final DateTime endDate;
final double progress;
final int totalTasks;
final int completedTasks;
final bool isActive;
StudyPlanEntry({
required this.id,
required this.title,
required this.type,
this.subject,
required this.startDate,
required this.endDate,
this.progress = 0.0,
this.totalTasks = 0,
this.completedTasks = 0,
this.isActive = true,
});
Map<String, dynamic> toMap() => {
'id': id,
'title': title,
'type': type,
'subject': subject,
'start_date': startDate.toIso8601String(),
'end_date': endDate.toIso8601String(),
'progress': progress,
'total_tasks': totalTasks,
'completed_tasks': completedTasks,
'is_active': isActive ? 1 : 0,
};
}
/// 练字练习记录模型
class PracticeRecord {
final String id;
final String templateId;
final String character;
final int strokeScore;
final int structureScore;
final int overallScore;
final String? strokeDataJson;
final DateTime practiceAt;
PracticeRecord({
required this.id,
required this.templateId,
required this.character,
this.strokeScore = 0,
this.structureScore = 0,
this.overallScore = 0,
this.strokeDataJson,
required this.practiceAt,
});
Map<String, dynamic> toMap() => {
'id': id,
'template_id': templateId,
'character': character,
'stroke_score': strokeScore,
'structure_score': structureScore,
'overall_score': overallScore,
'stroke_data_json': strokeDataJson,
'practice_at': practiceAt.toIso8601String(),
};
}
/// 平板端本地数据存储仓库
/// 使用SQLite持久化存储 + Hive内存级KV缓存
/// 支持：作业缓存、错题本、学习计划、练字记录、离线操作队列、使用时长记录
class PadLocalRepository {
/// 数据库实例（实际使用sqflite库）
// late final Database _db;
/// 单例
static PadLocalRepository? _instance;
static PadLocalRepository get instance {
_instance ??= PadLocalRepository._internal();
return _instance!;
}
PadLocalRepository._internal();
/// 初始化数据库，创建表结构并执行版本迁移
Future<void> initialize() async {
// 实际调用: openDatabase(path, version: padDbVersion, ...)
// 以下为建表SQL
// V1: 基础表
await _createTablesV1();
// V2: 增加学习计划表
await _createTablesV2();
// V3: 增加使用时长记录表
await _createTablesV3();
// V4: 增加练字记录表和索引优化
await _createTablesV4();
}
/// V1建表：作业缓存、作答进度、错题本、离线操作队列
Future<void> _createTablesV1() async {
// 作业缓存表
const createHomework = '''
CREATE TABLE IF NOT EXISTS ${PadDbTables.homework} (
id TEXT PRIMARY KEY,
title TEXT NOT NULL,
subject TEXT NOT NULL,
teacher_name TEXT,
status TEXT DEFAULT 'pending',
deadline TEXT,
content TEXT,
total_questions INTEGER DEFAULT 0,
answered_questions INTEGER DEFAULT 0,
cached_at TEXT NOT NULL
)
''';
// 作业题目缓存表
const createQuestion = '''
CREATE TABLE IF NOT EXISTS ${PadDbTables.homeworkQuestion} (
id TEXT PRIMARY KEY,
homework_id TEXT NOT NULL,
question_index INTEGER,
type TEXT DEFAULT 'write',
content TEXT,
image_url TEXT,
options TEXT,
correct_answer TEXT,
FOREIGN KEY (homework_id) REFERENCES ${PadDbTables.homework}(id)
)
''';
// 作答进度暂存表
const createProgress = '''
CREATE TABLE IF NOT EXISTS ${PadDbTables.answerProgress} (
id INTEGER PRIMARY KEY AUTOINCREMENT,
homework_id TEXT NOT NULL,
question_id TEXT NOT NULL,
text_answer TEXT,
stroke_data TEXT,
saved_at TEXT NOT NULL,
UNIQUE(homework_id, question_id)
)
''';
// 错题本表
const createErrorBook = '''
CREATE TABLE IF NOT EXISTS ${PadDbTables.errorBook} (
id TEXT PRIMARY KEY,
homework_id TEXT,
question_id TEXT,
subject TEXT NOT NULL,
knowledge_point TEXT,
question_content TEXT NOT NULL,
question_image_url TEXT,
student_answer TEXT,
correct_answer TEXT,
error_reason TEXT,
review_count INTEGER DEFAULT 0,
created_at TEXT NOT NULL,
last_review_at TEXT
)
''';
// 离线操作队列表
const createOffline = '''
CREATE TABLE IF NOT EXISTS ${PadDbTables.offlineAction} (
id INTEGER PRIMARY KEY AUTOINCREMENT,
action_type TEXT NOT NULL,
payload TEXT NOT NULL,
retry_count INTEGER DEFAULT 0,
created_at TEXT NOT NULL,
status TEXT DEFAULT 'pending'
)
''';
// 笔迹暂存表
const createStroke = '''
CREATE TABLE IF NOT EXISTS ${PadDbTables.strokeCache} (
id INTEGER PRIMARY KEY AUTOINCREMENT,
homework_id TEXT,
question_id TEXT,
page_id TEXT,
stroke_json TEXT NOT NULL,
pen_mac TEXT,
created_at TEXT NOT NULL
)
''';
// 实际执行建表SQL
// await _db.execute(createHomework);
// await _db.execute(createQuestion);
// await _db.execute(createProgress);
// await _db.execute(createErrorBook);
// await _db.execute(createOffline);
// await _db.execute(createStroke);
}
/// V2建表：学习计划与任务
Future<void> _createTablesV2() async {
const createPlan = '''
CREATE TABLE IF NOT EXISTS ${PadDbTables.studyPlan} (
id TEXT PRIMARY KEY,
title TEXT NOT NULL,
type TEXT NOT NULL,
subject TEXT,
start_date TEXT NOT NULL,
end_date TEXT NOT NULL,
progress REAL DEFAULT 0.0,
total_tasks INTEGER DEFAULT 0,
completed_tasks INTEGER DEFAULT 0,
is_active INTEGER DEFAULT 1
)
''';
const createTask = '''
CREATE TABLE IF NOT EXISTS ${PadDbTables.studyTask} (
id TEXT PRIMARY KEY,
plan_id TEXT NOT NULL,
title TEXT NOT NULL,
description TEXT,
target_date TEXT,
is_completed INTEGER DEFAULT 0,
completed_at TEXT,
FOREIGN KEY (plan_id) REFERENCES ${PadDbTables.studyPlan}(id)
)
''';
// await _db.execute(createPlan);
// await _db.execute(createTask);
}
/// V3建表：使用时长记录
Future<void> _createTablesV3() async {
const createUsage = '''
CREATE TABLE IF NOT EXISTS ${PadDbTables.usageRecord} (
id INTEGER PRIMARY KEY AUTOINCREMENT,
date TEXT NOT NULL,
app_name TEXT DEFAULT 'writech',
subject TEXT,
duration_seconds INTEGER DEFAULT 0,
start_time TEXT NOT NULL,
end_time TEXT
)
''';
// await _db.execute(createUsage);
}
/// V4建表：练字记录 + 索引
Future<void> _createTablesV4() async {
const createPractice = '''
CREATE TABLE IF NOT EXISTS ${PadDbTables.practiceRecord} (
id TEXT PRIMARY KEY,
template_id TEXT NOT NULL,
character TEXT NOT NULL,
stroke_score INTEGER DEFAULT 0,
structure_score INTEGER DEFAULT 0,
overall_score INTEGER DEFAULT 0,
stroke_data_json TEXT,
practice_at TEXT NOT NULL
)
''';
// 索引优化
const indexHomeworkStatus = '''
CREATE INDEX IF NOT EXISTS idx_homework_status
ON ${PadDbTables.homework}(status)
''';
const indexErrorSubject = '''
CREATE INDEX IF NOT EXISTS idx_error_subject
ON ${PadDbTables.errorBook}(subject)
''';
const indexPracticeChar = '''
CREATE INDEX IF NOT EXISTS idx_practice_char
ON ${PadDbTables.practiceRecord}(character)
''';
// await _db.execute(createPractice);
// await _db.execute(indexHomeworkStatus);
// await _db.execute(indexErrorSubject);
// await _db.execute(indexPracticeChar);
}
// ============================================================
// 作业缓存 CRUD
// ============================================================
/// 缓存作业到本地（用于离线作答）
Future<void> cacheHomework(CachedHomework homework) async {
// await _db.insert(
// PadDbTables.homework,
// homework.toMap(),
// conflictAlgorithm: ConflictAlgorithm.replace,
// );
}
/// 获取本地缓存的作业列表
Future<List<CachedHomework>> getCachedHomeworks({
String? status,
int limit = 50,
}) async {
// String where = '';
// List<dynamic> whereArgs = [];
// if (status != null) {
// where = 'status = ?';
// whereArgs = [status];
// }
// final maps = await _db.query(
// PadDbTables.homework,
// where: where.isNotEmpty ? where : null,
// whereArgs: whereArgs.isNotEmpty ? whereArgs : null,
// orderBy: 'cached_at DESC',
// limit: limit,
// );
// return maps.map((m) => CachedHomework.fromMap(m)).toList();
return [];
}
/// 保存作答进度到本地
Future<void> saveAnswerProgress({
required String homeworkId,
required String questionId,
String? textAnswer,
String? strokeDataJson,
}) async {
// await _db.insert(
// PadDbTables.answerProgress,
// {
// 'homework_id': homeworkId,
// 'question_id': questionId,
// 'text_answer': textAnswer,
// 'stroke_data': strokeDataJson,
// 'saved_at': DateTime.now().toIso8601String(),
// },
// conflictAlgorithm: ConflictAlgorithm.replace,
// );
}
/// 获取某作业的所有作答进度
Future<Map<String, Map<String, dynamic>>> getAnswerProgress(
String homeworkId,
) async {
// final maps = await _db.query(
// PadDbTables.answerProgress,
// where: 'homework_id = ?',
// whereArgs: [homeworkId],
// );
// final result = <String, Map<String, dynamic>>{};
// for (final m in maps) {
// result[m['question_id'] as String] = m;
// }
// return result;
return {};
}
// ============================================================
// 错题本 CRUD
// ============================================================
/// 添加错题记录
Future<void> addErrorEntry(ErrorBookEntry entry) async {
// await _db.insert(
// PadDbTables.errorBook,
// entry.toMap(),
// conflictAlgorithm: ConflictAlgorithm.replace,
// );
}
/// 获取错题列表（支持按科目/知识点筛选）
Future<List<ErrorBookEntry>> getErrorEntries({
String? subject,
String? knowledgePoint,
int limit = 50,
int offset = 0,
}) async {
// final conditions = <String>[];
// final args = <dynamic>[];
// if (subject != null) {
// conditions.add('subject = ?');
// args.add(subject);
// }
// if (knowledgePoint != null) {
// conditions.add('knowledge_point = ?');
// args.add(knowledgePoint);
// }
// final maps = await _db.query(
// PadDbTables.errorBook,
// where: conditions.isNotEmpty ? conditions.join(' AND ') : null,
// whereArgs: args.isNotEmpty ? args : null,
// orderBy: 'created_at DESC',
// limit: limit,
// offset: offset,
// );
// return maps.map((m) => ErrorBookEntry.fromMap(m)).toList();
return [];
}
/// 更新错题复习次数
Future<void> updateErrorReviewCount(String entryId) async {
// await _db.rawUpdate('''
// UPDATE ${PadDbTables.errorBook}
// SET review_count = review_count + 1,
// last_review_at = ?
// WHERE id = ?
// ''', [DateTime.now().toIso8601String(), entryId]);
}
/// 获取错题统计（按科目分组计数）
Future<Map<String, int>> getErrorStatsBySubject() async {
// final maps = await _db.rawQuery('''
// SELECT subject, COUNT(*) as count
// FROM ${PadDbTables.errorBook}
// GROUP BY subject
// ''');
// return {for (var m in maps) m['subject'] as String: m['count'] as int};
return {};
}
// ============================================================
// 学习计划 CRUD
// ============================================================
/// 保存学习计划
Future<void> saveStudyPlan(StudyPlanEntry plan) async {
// await _db.insert(
// PadDbTables.studyPlan,
// plan.toMap(),
// conflictAlgorithm: ConflictAlgorithm.replace,
// );
}
/// 获取活跃的学习计划列表
Future<List<Map<String, dynamic>>> getActiveStudyPlans() async {
// return await _db.query(
// PadDbTables.studyPlan,
// where: 'is_active = 1',
// orderBy: 'start_date ASC',
// );
return [];
}
/// 更新学习计划进度
Future<void> updatePlanProgress(
String planId,
double progress,
int completedTasks,
) async {
// await _db.update(
// PadDbTables.studyPlan,
// {'progress': progress, 'completed_tasks': completedTasks},
// where: 'id = ?',
// whereArgs: [planId],
// );
}
// ============================================================
// 练字记录
// ============================================================
/// 保存练字记录
Future<void> savePracticeRecord(PracticeRecord record) async {
// await _db.insert(
// PadDbTables.practiceRecord,
// record.toMap(),
// conflictAlgorithm: ConflictAlgorithm.replace,
// );
}
/// 获取某字的练习历史（查看进步轨迹）
Future<List<Map<String, dynamic>>> getPracticeHistory(
String character, {
int limit = 20,
}) async {
// return await _db.query(
// PadDbTables.practiceRecord,
// where: 'character = ?',
// whereArgs: [character],
// orderBy: 'practice_at DESC',
// limit: limit,
// );
return [];
}
// ============================================================
// 离线操作队列
// ============================================================
/// 添加离线操作到队列
Future<void> enqueueOfflineAction(
String actionType,
Map<String, dynamic> payload,
) async {
// await _db.insert(PadDbTables.offlineAction, {
// 'action_type': actionType,
// 'payload': jsonEncode(payload),
// 'created_at': DateTime.now().toIso8601String(),
// 'status': 'pending',
// });
}
/// 获取待执行的离线操作
Future<List<Map<String, dynamic>>> getPendingOfflineActions() async {
// return await _db.query(
// PadDbTables.offlineAction,
// where: 'status = ? AND retry_count < 5',
// whereArgs: ['pending'],
// orderBy: 'created_at ASC',
// );
return [];
}
/// 标记离线操作完成
Future<void> markOfflineActionDone(int actionId) async {
// await _db.update(
// PadDbTables.offlineAction,
// {'status': 'done'},
// where: 'id = ?',
// whereArgs: [actionId],
// );
}
// ============================================================
// 使用时长记录
// ============================================================
/// 记录使用时长
Future<void> recordUsage({
required String date,
required int durationSeconds,
required String startTime,
String? endTime,
String? subject,
}) async {
// await _db.insert(PadDbTables.usageRecord, {
// 'date': date,
// 'duration_seconds': durationSeconds,
// 'start_time': startTime,
// 'end_time': endTime,
// 'subject': subject,
// });
}
/// 获取某日使用总时长（秒）
Future<int> getDailyUsage(String date) async {
// final result = await _db.rawQuery('''
// SELECT COALESCE(SUM(duration_seconds), 0) as total
// FROM ${PadDbTables.usageRecord}
// WHERE date = ?
// ''', [date]);
// return result.first['total'] as int? ?? 0;
return 0;
}
// ============================================================
// 数据库维护
// ============================================================
/// 清理过期缓存数据（30天前的作业缓存、90天前的笔迹暂存）
Future<void> cleanExpiredData() async {
final thirtyDaysAgo = DateTime.now()
.subtract(const Duration(days: 30))
.toIso8601String();
final ninetyDaysAgo = DateTime.now()
.subtract(const Duration(days: 90))
.toIso8601String();
// await _db.delete(
// PadDbTables.homework,
// where: 'cached_at < ? AND status IN (?, ?)',
// whereArgs: [thirtyDaysAgo, 'graded', 'expired'],
// );
// await _db.delete(
// PadDbTables.strokeCache,
// where: 'created_at < ?',
// whereArgs: [ninetyDaysAgo],
// );
// await _db.delete(
// PadDbTables.offlineAction,
// where: 'status = ? AND created_at < ?',
// whereArgs: ['done', thirtyDaysAgo],
// );
}
/// 获取本地数据库存储大小（字节）
Future<int> getDatabaseSize() async {
// final dbPath = await getDatabasesPath();
// final file = File('$dbPath/writech_pad.db');
// return file.existsSync() ? file.lengthSync() : 0;
return 0;
}
/// 关闭数据库
Future<void> close() async {
// await _db.close();
}
}
service/
service/api_service.dart
// 自然写互动课堂平板端应用软件 V1.0
// service/api_service.dart - 云平台API服务（Dio HTTP客户端）
import 'dart:async';
import 'dart:convert';
import 'dart:io';
import 'package:dio/dio.dart';
import 'package:flutter_secure_storage/flutter_secure_storage.dart';
import 'package:crypto/crypto.dart';
/// 云平台API基础路径配置
class ApiConfig {
/// 生产环境API地址
static const String productionBaseUrl = 'https://api.writech.com/v1';
/// 测试环境API地址
static const String stagingBaseUrl = 'https://staging-api.writech.com/v1';
/// 连接超时时间（毫秒）
static const int connectTimeout = 15000;
/// 接收超时时间（毫秒）
static const int receiveTimeout = 30000;
/// Token刷新路径
static const String refreshTokenPath = '/auth/refresh';
/// 最大重试次数
static const int maxRetryCount = 3;
/// HMAC签名密钥标识
static const String hmacKeyId = 'writech-pad-v1';
}
/// API响应数据统一封装
class ApiResponse<T> {
final int code;
final String message;
final T? data;
final String? requestId;
ApiResponse({
required this.code,
required this.message,
this.data,
this.requestId,
});
/// 判断请求是否成功
bool get isSuccess => code == 0 || code == 200;
/// 从JSON解析响应
factory ApiResponse.fromJson(
Map<String, dynamic> json,
T Function(dynamic)? fromData,
) {
return ApiResponse(
code: json['code'] ?? -1,
message: json['message'] ?? '未知错误',
data: json['data'] != null && fromData != null
? fromData(json['data'])
: json['data'] as T?,
requestId: json['request_id'],
);
}
}
/// 离线请求队列项
class OfflineRequest {
final String id;
final String method;
final String path;
final Map<String, dynamic>? data;
final DateTime createdAt;
int retryCount;
OfflineRequest({
required this.id,
required this.method,
required this.path,
this.data,
required this.createdAt,
this.retryCount = 0,
});
/// 序列化为JSON用于本地持久化
Map<String, dynamic> toJson() => {
'id': id,
'method': method,
'path': path,
'data': data,
'created_at': createdAt.toIso8601String(),
'retry_count': retryCount,
};
/// 从JSON反序列化
factory OfflineRequest.fromJson(Map<String, dynamic> json) {
return OfflineRequest(
id: json['id'],
method: json['method'],
path: json['path'],
data: json['data'],
createdAt: DateTime.parse(json['created_at']),
retryCount: json['retry_count'] ?? 0,
);
}
}
/// 平板端云平台API服务
/// 负责与云平台的所有HTTP通信，包括：
/// - JWT双令牌认证与自动刷新
/// - HMAC-SHA256请求签名
/// - 离线请求队列暂存
/// - 学生简化登录（班级+姓名/学号）
class PadApiService {
late final Dio _dio;
final FlutterSecureStorage _secureStorage = const FlutterSecureStorage();
/// 当前访问令牌
String? _accessToken;
/// 刷新令牌
String? _refreshToken;
/// Token刷新锁，防止并发刷新
Completer<bool>? _refreshCompleter;
/// 离线请求队列
final List<OfflineRequest> _offlineQueue = [];
/// 网络状态标志
bool _isOnline = true;
/// API事件流控制器（登录状态变化等）
final StreamController<String> _eventController =
StreamController<String>.broadcast();
/// API事件流
Stream<String> get eventStream => _eventController.stream;
/// 单例实例
static PadApiService? _instance;
/// 获取单例
static PadApiService get instance {
_instance ??= PadApiService._internal();
return _instance!;
}
/// 私有构造函数，初始化Dio客户端
PadApiService._internal() {
_dio = Dio(BaseOptions(
baseUrl: ApiConfig.productionBaseUrl,
connectTimeout: Duration(milliseconds: ApiConfig.connectTimeout),
receiveTimeout: Duration(milliseconds: ApiConfig.receiveTimeout),
headers: {
'Content-Type': 'application/json',
'X-Client-Platform': 'pad',
'X-Client-Version': '1.0.0',
},
));
// 添加请求拦截器：自动附加Token和HMAC签名
_dio.interceptors.add(InterceptorsWrapper(
onRequest: _onRequest,
onResponse: _onResponse,
onError: _onError,
));
// 从安全存储恢复令牌
_restoreTokens();
}
/// 从安全存储恢复上次保存的令牌
Future<void> _restoreTokens() async {
_accessToken = await _secureStorage.read(key: 'access_token');
_refreshToken = await _secureStorage.read(key: 'refresh_token');
}
/// 请求拦截器：附加Authorization头和HMAC签名
void _onRequest(
RequestOptions options,
RequestInterceptorHandler handler,
) {
// 附加JWT访问令牌
if (_accessToken != null) {
options.headers['Authorization'] = 'Bearer $_accessToken';
}
// 生成HMAC-SHA256请求签名
final timestamp = DateTime.now().millisecondsSinceEpoch.toString();
options.headers['X-Timestamp'] = timestamp;
final signature = _generateSignature(
options.method,
options.path,
timestamp,
options.data,
);
options.headers['X-Signature'] = signature;
handler.next(options);
}
/// 响应拦截器：统一处理响应
void _onResponse(
Response response,
ResponseInterceptorHandler handler,
) {
handler.next(response);
}
/// 错误拦截器：处理401自动刷新Token、离线暂存等
Future<void> _onError(
DioException error,
ErrorInterceptorHandler handler,
) async {
// 网络不可用时，将请求加入离线队列
if (error.type == DioExceptionType.connectionError ||
error.type == DioExceptionType.connectionTimeout) {
_isOnline = false;
_enqueueOfflineRequest(error.requestOptions);
handler.reject(error);
return;
}
// 401未授权：尝试刷新Token后重试
if (error.response?.statusCode == 401) {
final refreshSuccess = await _refreshAccessToken();
if (refreshSuccess) {
// Token刷新成功，使用新Token重试原请求
final retryOptions = error.requestOptions;
retryOptions.headers['Authorization'] = 'Bearer $_accessToken';
try {
final response = await _dio.fetch(retryOptions);
handler.resolve(response);
return;
} catch (retryError) {
// 重试也失败了
}
} else {
// Token刷新失败，通知登出
_eventController.add('token_expired');
}
}
handler.reject(error);
}
/// 生成HMAC-SHA256请求签名
/// 签名内容: METHOD\nPATH\nTIMESTAMP\nBODY_SHA256
String _generateSignature(
String method,
String path,
String timestamp,
dynamic body,
) {
// 计算请求体SHA256哈希
String bodyHash = '';
if (body != null) {
final bodyStr = body is String ? body : jsonEncode(body);
bodyHash = sha256.convert(utf8.encode(bodyStr)).toString();
}
// 拼接签名原文
final signContent = '$method\n$path\n$timestamp\n$bodyHash';
final hmacKey = utf8.encode(ApiConfig.hmacKeyId);
final hmac = Hmac(sha256, hmacKey);
final digest = hmac.convert(utf8.encode(signContent));
return digest.toString();
}
/// 刷新访问令牌
/// 使用Completer防止并发多次刷新
Future<bool> _refreshAccessToken() async {
// 如果已经在刷新中，等待结果
if (_refreshCompleter != null) {
return _refreshCompleter!.future;
}
_refreshCompleter = Completer<bool>();
try {
if (_refreshToken == null) {
_refreshCompleter!.complete(false);
return false;
}
// 发送刷新请求（不经过拦截器避免死循环）
final response = await Dio().post(
'${ApiConfig.productionBaseUrl}${ApiConfig.refreshTokenPath}',
data: {'refresh_token': _refreshToken},
);
if (response.statusCode == 200 && response.data['code'] == 0) {
_accessToken = response.data['data']['access_token'];
_refreshToken = response.data['data']['refresh_token'];
// 持久化新令牌到安全存储
await _secureStorage.write(
key: 'access_token',
value: _accessToken,
);
await _secureStorage.write(
key: 'refresh_token',
value: _refreshToken,
);
_refreshCompleter!.complete(true);
return true;
}
_refreshCompleter!.complete(false);
return false;
} catch (e) {
_refreshCompleter!.complete(false);
return false;
} finally {
_refreshCompleter = null;
}
}
/// 将失败的请求加入离线队列
void _enqueueOfflineRequest(RequestOptions options) {
final offlineReq = OfflineRequest(
id: DateTime.now().microsecondsSinceEpoch.toString(),
method: options.method,
path: options.path,
data: options.data is Map ? options.data : null,
createdAt: DateTime.now(),
);
_offlineQueue.add(offlineReq);
}
/// 网络恢复后，批量重发离线队列中的请求
Future<void> flushOfflineQueue() async {
if (_offlineQueue.isEmpty) return;
_isOnline = true;
final pendingRequests = List<OfflineRequest>.from(_offlineQueue);
_offlineQueue.clear();
for (final req in pendingRequests) {
try {
if (req.retryCount >= ApiConfig.maxRetryCount) continue;
req.retryCount++;
switch (req.method.toUpperCase()) {
case 'POST':
await _dio.post(req.path, data: req.data);
break;
case 'PUT':
await _dio.put(req.path, data: req.data);
break;
case 'DELETE':
await _dio.delete(req.path);
break;
default:
await _dio.get(req.path);
}
} catch (e) {
// 重发失败的请求重新加入队列
if (req.retryCount < ApiConfig.maxRetryCount) {
_offlineQueue.add(req);
}
}
}
}
// ============================================================
// 学生登录接口（简化登录，班级+姓名/学号）
// ============================================================
/// 学生简化登录（无需手机号，仅班级+姓名或学号）
Future<ApiResponse<Map<String, dynamic>>> studentLogin({
required String schoolCode,
required String classId,
required String studentName,
String? studentNo,
}) async {
try {
final response = await _dio.post('/auth/student/login', data: {
'school_code': schoolCode,
'class_id': classId,
'student_name': studentName,
'student_no': studentNo,
'device_type': 'pad',
});
final result = ApiResponse<Map<String, dynamic>>.fromJson(
response.data,
(data) => data as Map<String, dynamic>,
);
// 保存登录令牌
if (result.isSuccess && result.data != null) {
_accessToken = result.data!['access_token'];
_refreshToken = result.data!['refresh_token'];
await _secureStorage.write(
key: 'access_token',
value: _accessToken,
);
await _secureStorage.write(
key: 'refresh_token',
value: _refreshToken,
);
}
return result;
} on DioException catch (e) {
return ApiResponse(code: -1, message: e.message ?? '网络请求失败');
}
}
/// 教师登录（手机号+验证码）
Future<ApiResponse<Map<String, dynamic>>> teacherLogin({
required String phone,
required String verifyCode,
}) async {
try {
final response = await _dio.post('/auth/teacher/login', data: {
'phone': phone,
'verify_code': verifyCode,
'device_type': 'pad',
});
final result = ApiResponse<Map<String, dynamic>>.fromJson(
response.data,
(data) => data as Map<String, dynamic>,
);
if (result.isSuccess && result.data != null) {
_accessToken = result.data!['access_token'];
_refreshToken = result.data!['refresh_token'];
await _secureStorage.write(
key: 'access_token',
value: _accessToken,
);
await _secureStorage.write(
key: 'refresh_token',
value: _refreshToken,
);
}
return result;
} on DioException catch (e) {
return ApiResponse(code: -1, message: e.message ?? '网络请求失败');
}
}
// ============================================================
// 作业相关接口
// ============================================================
/// 获取学生待完成作业列表
Future<ApiResponse<List<dynamic>>> getHomeworkList({
int page = 1,
int pageSize = 20,
String? status,
}) async {
try {
final response = await _dio.get('/homework/list', queryParameters: {
'page': page,
'page_size': pageSize,
if (status != null) 'status': status,
});
return ApiResponse<List<dynamic>>.fromJson(
response.data,
(data) => data as List<dynamic>,
);
} on DioException catch (e) {
return ApiResponse(code: -1, message: e.message ?? '获取作业列表失败');
}
}
/// 下载作业详情（含题目内容，支持离线作答）
Future<ApiResponse<Map<String, dynamic>>> downloadHomework(
String homeworkId,
) async {
try {
final response = await _dio.get('/homework/detail/$homeworkId');
return ApiResponse<Map<String, dynamic>>.fromJson(
response.data,
(data) => data as Map<String, dynamic>,
);
} on DioException catch (e) {
return ApiResponse(code: -1, message: e.message ?? '下载作业失败');
}
}
/// 提交作业（含笔迹数据）
Future<ApiResponse<Map<String, dynamic>>> submitHomework({
required String homeworkId,
required List<Map<String, dynamic>> strokePages,
int? timeCostSeconds,
}) async {
try {
final response = await _dio.post('/homework/submit', data: {
'homework_id': homeworkId,
'stroke_pages': strokePages,
'time_cost': timeCostSeconds,
'submit_time': DateTime.now().toIso8601String(),
});
return ApiResponse<Map<String, dynamic>>.fromJson(
response.data,
(data) => data as Map<String, dynamic>,
);
} on DioException catch (e) {
// 离线时暂存提交请求
if (!_isOnline) {
_enqueueOfflineRequest(e.requestOptions);
}
return ApiResponse(code: -1, message: e.message ?? '提交作业失败');
}
}
/// 获取作业批改结果
Future<ApiResponse<Map<String, dynamic>>> getHomeworkResult(
String homeworkId,
) async {
try {
final response = await _dio.get('/homework/result/$homeworkId');
return ApiResponse<Map<String, dynamic>>.fromJson(
response.data,
(data) => data as Map<String, dynamic>,
);
} on DioException catch (e) {
return ApiResponse(code: -1, message: e.message ?? '获取批改结果失败');
}
}
// ============================================================
// 字帖练习接口
// ============================================================
/// 获取字帖模板列表（按年级/学科分类）
Future<ApiResponse<List<dynamic>>> getCopybookTemplates({
required String grade,
String? subject,
int page = 1,
}) async {
try {
final response = await _dio.get('/copybook/templates', queryParameters: {
'grade': grade,
'subject': subject,
'page': page,
});
return ApiResponse<List<dynamic>>.fromJson(
response.data,
(data) => data as List<dynamic>,
);
} on DioException catch (e) {
return ApiResponse(code: -1, message: e.message ?? '获取字帖失败');
}
}
/// 上传练字笔迹评分
Future<ApiResponse<Map<String, dynamic>>> submitPracticeStroke({
required String templateId,
required String character,
required List<Map<String, dynamic>> strokes,
}) async {
try {
final response = await _dio.post('/copybook/evaluate', data: {
'template_id': templateId,
'character': character,
'strokes': strokes,
});
return ApiResponse<Map<String, dynamic>>.fromJson(
response.data,
(data) => data as Map<String, dynamic>,
);
} on DioException catch (e) {
return ApiResponse(code: -1, message: e.message ?? '提交练字评分失败');
}
}
// ============================================================
// 错题本接口
// ============================================================
/// 获取错题列表（按知识点/科目分类）
Future<ApiResponse<List<dynamic>>> getErrorBookList({
String? subject,
String? knowledgePoint,
int page = 1,
int pageSize = 20,
}) async {
try {
final response = await _dio.get('/error-book/list', queryParameters: {
if (subject != null) 'subject': subject,
if (knowledgePoint != null) 'knowledge_point': knowledgePoint,
'page': page,
'page_size': pageSize,
});
return ApiResponse<List<dynamic>>.fromJson(
response.data,
(data) => data as List<dynamic>,
);
} on DioException catch (e) {
return ApiResponse(code: -1, message: e.message ?? '获取错题本失败');
}
}
// ============================================================
// 学情与学习计划接口
// ============================================================
/// 获取学生个人学情概览
Future<ApiResponse<Map<String, dynamic>>> getStudentProfile() async {
try {
final response = await _dio.get('/profile/student/overview');
return ApiResponse<Map<String, dynamic>>.fromJson(
response.data,
(data) => data as Map<String, dynamic>,
);
} on DioException catch (e) {
return ApiResponse(code: -1, message: e.message ?? '获取学情失败');
}
}
/// 获取学习计划列表
Future<ApiResponse<List<dynamic>>> getStudyPlans() async {
try {
final response = await _dio.get('/study-plan/list');
return ApiResponse<List<dynamic>>.fromJson(
response.data,
(data) => data as List<dynamic>,
);
} on DioException catch (e) {
return ApiResponse(code: -1, message: e.message ?? '获取学习计划失败');
}
}
/// 更新学习计划进度
Future<ApiResponse<void>> updateStudyPlanProgress({
required String planId,
required String taskId,
required double progress,
}) async {
try {
final response = await _dio.put('/study-plan/progress', data: {
'plan_id': planId,
'task_id': taskId,
'progress': progress,
'update_time': DateTime.now().toIso8601String(),
});
return ApiResponse<void>.fromJson(response.data, null);
} on DioException catch (e) {
return ApiResponse(code: -1, message: e.message ?? '更新进度失败');
}
}
/// 登出，清除本地令牌
Future<void> logout() async {
try {
await _dio.post('/auth/logout');
} catch (_) {
// 忽略登出请求失败
}
_accessToken = null;
_refreshToken = null;
await _secureStorage.delete(key: 'access_token');
await _secureStorage.delete(key: 'refresh_token');
_eventController.add('logged_out');
}
/// 释放资源
void dispose() {
_eventController.close();
_dio.close();
}
}
service/ble_service.dart
// 自然写互动课堂平板端应用软件 V1.0
// service/ble_service.dart - BLE蓝牙点阵笔连接服务
import 'dart:async';
import 'dart:typed_data';
/// BLE服务UUID常量定义
/// 基于自然写点阵笔自定义GATT Service规范
class PadBleConstants {
/// 点阵笔主服务UUID
static const String penServiceUuid = '0000ffe0-0000-1000-8000-00805f9b34fb';
/// 笔迹坐标数据特征值UUID（Notify）
static const String strokeCharUuid = '0000ffe1-0000-1000-8000-00805f9b34fb';
/// 笔控制指令特征值UUID（Write）
static const String controlCharUuid = '0000ffe2-0000-1000-8000-00805f9b34fb';
/// 电量信息特征值UUID（Read/Notify）
static const String batteryCharUuid = '0000ffe3-0000-1000-8000-00805f9b34fb';
/// 设备信息服务UUID
static const String deviceInfoUuid = '0000180a-0000-1000-8000-00805f9b34fb';
/// 扫描超时时间（秒）
static const int scanTimeoutSeconds = 15;
/// 自动重连延迟（秒）
static const int reconnectDelaySeconds = 3;
/// 最大重连次数
static const int maxReconnectAttempts = 10;
/// MTU协商大小
static const int requestedMtu = 247;
/// 笔迹数据缓冲批量回调阈值
static const int strokeBatchSize = 8;
/// 电量读取间隔（秒）
static const int batteryReadInterval = 60;
}
/// 单个笔迹坐标点数据
class PadPenPoint {
/// X坐标（0.01mm精度，16位无符号）
final double x;
/// Y坐标（0.01mm精度，16位无符号）
final double y;
/// 压力值（0-255，8位无符号）
final int pressure;
/// 时间戳（相对值，16位无符号，单位ms）
final int timestamp;
/// 是否为落笔点
final bool isPenDown;
PadPenPoint({
required this.x,
required this.y,
required this.pressure,
required this.timestamp,
this.isPenDown = false,
});
@override
String toString() =>
'PadPenPoint(x: ${x.toStringAsFixed(2)}, y: ${y.toStringAsFixed(2)}, '
'p: $pressure, t: $timestamp)';
}
/// 点阵笔设备信息
class PadPenDevice {
/// 设备蓝牙MAC地址
final String macAddress;
/// 设备名称
final String name;
/// 信号强度（RSSI）
int rssi;
/// 当前连接状态
PenConnectionState connectionState;
/// 电量百分比（0-100）
int batteryLevel;
/// 固件版本号
String? firmwareVersion;
/// 当前所在点阵码页面ID
String? currentPageId;
PadPenDevice({
required this.macAddress,
required this.name,
this.rssi = -100,
this.connectionState = PenConnectionState.disconnected,
this.batteryLevel = -1,
this.firmwareVersion,
this.currentPageId,
});
}
/// 笔连接状态枚举
enum PenConnectionState {
/// 未连接
disconnected,
/// 正在扫描
scanning,
/// 正在连接
connecting,
/// 已连接
connected,
/// 正在断开
disconnecting,
/// 自动重连中
reconnecting,
}
/// 笔迹数据事件（批量坐标点回调）
class PenStrokeEvent {
/// 来源笔的MAC地址
final String penMac;
/// 坐标点列表
final List<PadPenPoint> points;
/// 所在页面ID（点阵码识别）
final String? pageId;
PenStrokeEvent({
required this.penMac,
required this.points,
this.pageId,
});
}
/// BLE蓝牙点阵笔连接服务
/// 负责扫描、连接、数据接收、电量监控、自动重连等功能
/// 平板端支持同时连接1支笔（学生个人使用场景）
class PadBleService {
/// 已发现的设备列表
final List<PadPenDevice> _discoveredDevices = [];
/// 当前已连接的笔
PadPenDevice? _connectedPen;
/// 笔迹数据缓冲区（累积到阈值后批量回调）
final List<PadPenPoint> _strokeBuffer = [];
/// 扫描结果流
final StreamController<List<PadPenDevice>> _scanController =
StreamController<List<PadPenDevice>>.broadcast();
/// 笔迹数据事件流
final StreamController<PenStrokeEvent> _strokeController =
StreamController<PenStrokeEvent>.broadcast();
/// 连接状态变化流
final StreamController<PenConnectionState> _connectionController =
StreamController<PenConnectionState>.broadcast();
/// 电量变化流
final StreamController<int> _batteryController =
StreamController<int>.broadcast();
/// 自动重连计数器
int _reconnectAttempts = 0;
/// 重连定时器
Timer? _reconnectTimer;
/// 电量读取定时器
Timer? _batteryTimer;
/// 是否正在扫描
bool _isScanning = false;
/// 公开的流
Stream<List<PadPenDevice>> get scanStream => _scanController.stream;
Stream<PenStrokeEvent> get strokeStream => _strokeController.stream;
Stream<PenConnectionState> get connectionStream =>
_connectionController.stream;
Stream<int> get batteryStream => _batteryController.stream;
/// 获取当前连接的笔
PadPenDevice? get connectedPen => _connectedPen;
/// 开始扫描附近的点阵笔设备
/// 按服务UUID过滤，仅发现自然写点阵笔
Future<void> startScan() async {
if (_isScanning) return;
_isScanning = true;
_discoveredDevices.clear();
// 通知扫描状态
_connectionController.add(PenConnectionState.scanning);
// 模拟BLE扫描（实际使用flutter_blue_plus库）
// 过滤条件：仅发现包含pen_service_uuid的设备
// scanFilters: [ScanFilter(serviceUuid: PadBleConstants.penServiceUuid)]
// 设置扫描超时
Timer(Duration(seconds: PadBleConstants.scanTimeoutSeconds), () {
stopScan();
});
}
/// 停止扫描
Future<void> stopScan() async {
_isScanning = false;
// 实际调用: FlutterBluePlus.stopScan()
}
/// 处理扫描结果回调
void _onScanResult(String mac, String name, int rssi) {
// 检查是否已发现过
final existingIndex = _discoveredDevices.indexWhere(
(d) => d.macAddress == mac,
);
if (existingIndex >= 0) {
// 更新已有设备的RSSI
_discoveredDevices[existingIndex].rssi = rssi;
} else {
// 添加新发现的设备
_discoveredDevices.add(PadPenDevice(
macAddress: mac,
name: name,
rssi: rssi,
));
}
// 按信号强度降序排列
_discoveredDevices.sort((a, b) => b.rssi.compareTo(a.rssi));
_scanController.add(List.from(_discoveredDevices));
}
/// 连接指定的点阵笔
/// [device] 要连接的笔设备信息
Future<bool> connectPen(PadPenDevice device) async {
// 先断开已有连接
if (_connectedPen != null) {
await disconnectPen();
}
device.connectionState = PenConnectionState.connecting;
_connectionController.add(PenConnectionState.connecting);
try {
// 停止扫描
await stopScan();
// 执行BLE连接
// 实际调用: device.connect(timeout: Duration(seconds: 10))
// 协商MTU
// await device.requestMtu(PadBleConstants.requestedMtu);
// 发现服务和特征值
// final services = await device.discoverServices();
// 查找笔迹数据特征值并订阅Notify
// 设置连接成功状态
device.connectionState = PenConnectionState.connected;
_connectedPen = device;
_reconnectAttempts = 0;
_connectionController.add(PenConnectionState.connected);
// 启动电量定时读取
_startBatteryMonitor();
// 订阅笔迹数据特征值
_subscribeStrokeData();
return true;
} catch (e) {
device.connectionState = PenConnectionState.disconnected;
_connectionController.add(PenConnectionState.disconnected);
return false;
}
}
/// 订阅笔迹坐标数据Notify特征值
void _subscribeStrokeData() {
// 实际调用:
// characteristic.setNotifyValue(true);
// characteristic.onValueReceived.listen(_onStrokeDataReceived);
}
/// 处理接收到的笔迹原始数据（7字节紧凑编码）
/// 数据格式：[X_H, X_L, Y_H, Y_L, Pressure, TS_H, TS_L]
/// X: 16位无符号（0.01mm精度）
/// Y: 16位无符号（0.01mm精度）
/// Pressure: 8位无符号（0-255）
/// Timestamp: 16位无符号（相对毫秒）
void _onStrokeDataReceived(Uint8List rawData) {
if (rawData.length < 7) return;
// 可能包含多个坐标点（每7字节一个）
int offset = 0;
while (offset + 7 <= rawData.length) {
// 解码X坐标（大端序16位）
final int rawX = (rawData[offset] << 8) | rawData[offset + 1];
final double x = rawX * 0.01; // 转换为毫米
// 解码Y坐标
final int rawY = (rawData[offset + 2] << 8) | rawData[offset + 3];
final double y = rawY * 0.01;
// 解码压力值
final int pressure = rawData[offset + 4];
// 解码时间戳
final int timestamp =
(rawData[offset + 5] << 8) | rawData[offset + 6];
// 判断落笔/抬笔（压力值>0为落笔）
final bool isPenDown = pressure > 0;
final point = PadPenPoint(
x: x,
y: y,
pressure: pressure,
timestamp: timestamp,
isPenDown: isPenDown,
);
_strokeBuffer.add(point);
offset += 7;
}
// CRC-16 CCITT校验（如果数据包尾部有2字节CRC）
if (rawData.length > offset + 1) {
final int receivedCrc = (rawData[offset] << 8) | rawData[offset + 1];
final int calculatedCrc = _calculateCrc16(
rawData.sublist(0, offset),
);
if (receivedCrc != calculatedCrc) {
// CRC校验失败，丢弃本批数据
_strokeBuffer.clear();
return;
}
}
// 达到批量阈值后回调
if (_strokeBuffer.length >= PadBleConstants.strokeBatchSize) {
_flushStrokeBuffer();
}
}
/// 将缓冲区中的笔迹数据批量回调
void _flushStrokeBuffer() {
if (_strokeBuffer.isEmpty || _connectedPen == null) return;
final event = PenStrokeEvent(
penMac: _connectedPen!.macAddress,
points: List.from(_strokeBuffer),
pageId: _connectedPen!.currentPageId,
);
_strokeController.add(event);
_strokeBuffer.clear();
}
/// CRC-16 CCITT校验算法
/// 多项式: 0x1021, 初始值: 0xFFFF
int _calculateCrc16(Uint8List data) {
int crc = 0xFFFF;
for (int i = 0; i < data.length; i++) {
crc ^= (data[i] << 8);
for (int j = 0; j < 8; j++) {
if ((crc & 0x8000) != 0) {
crc = ((crc << 1) ^ 0x1021) & 0xFFFF;
} else {
crc = (crc << 1) & 0xFFFF;
}
}
}
return crc;
}
/// 启动电量定时读取
void _startBatteryMonitor() {
_batteryTimer?.cancel();
_batteryTimer = Timer.periodic(
Duration(seconds: PadBleConstants.batteryReadInterval),
(_) => _readBatteryLevel(),
);
// 立即读取一次
_readBatteryLevel();
}
/// 读取笔电量
Future<void> _readBatteryLevel() async {
if (_connectedPen == null) return;
try {
// 实际调用: 读取battery特征值
// final value = await batteryCharacteristic.read();
// _connectedPen!.batteryLevel = value[0];
// _batteryController.add(_connectedPen!.batteryLevel);
} catch (e) {
// 读取失败，忽略
}
}
/// 向笔发送控制指令
/// [command] 指令类型（如：LED闪烁、蜂鸣提示、固件信息查询）
Future<void> sendCommand(int command, [Uint8List? payload]) async {
if (_connectedPen == null) return;
// 构建指令包：[CMD, LEN, PAYLOAD..., CRC_H, CRC_L]
final List<int> packet = [command];
if (payload != null) {
packet.add(payload.length);
packet.addAll(payload);
} else {
packet.add(0);
}
// 追加CRC校验
final crc = _calculateCrc16(Uint8List.fromList(packet));
packet.add((crc >> 8) & 0xFF);
packet.add(crc & 0xFF);
// 实际调用: controlCharacteristic.write(Uint8List.fromList(packet));
}
/// 断开当前笔连接
Future<void> disconnectPen() async {
_batteryTimer?.cancel();
_reconnectTimer?.cancel();
if (_connectedPen != null) {
_connectedPen!.connectionState = PenConnectionState.disconnecting;
_connectionController.add(PenConnectionState.disconnecting);
// 实际调用: device.disconnect();
_connectedPen!.connectionState = PenConnectionState.disconnected;
_connectedPen = null;
_connectionController.add(PenConnectionState.disconnected);
}
// 清空缓冲区
_flushStrokeBuffer();
}
/// 处理连接意外断开，启动自动重连
void _onDisconnected(PadPenDevice device) {
if (_reconnectAttempts >= PadBleConstants.maxReconnectAttempts) {
// 超过最大重连次数，放弃重连
_connectionController.add(PenConnectionState.disconnected);
return;
}
_connectionController.add(PenConnectionState.reconnecting);
_reconnectAttempts++;
// 指数退避延迟重连
final delay = PadBleConstants.reconnectDelaySeconds * _reconnectAttempts;
final clampedDelay = delay > 30 ? 30 : delay;
_reconnectTimer = Timer(Duration(seconds: clampedDelay), () async {
final success = await connectPen(device);
if (!success) {
_onDisconnected(device);
}
});
}
/// 释放所有资源
void dispose() {
_batteryTimer?.cancel();
_reconnectTimer?.cancel();
_scanController.close();
_strokeController.close();
_connectionController.close();
_batteryController.close();
_strokeBuffer.clear();
}
}