John/system-design
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
60f336e345162d26d3fe9b4ec58afe8ea681b6a1
system-design/software-copyright/09-writech-app-board/自然写互动课堂智慧黑板端应用软件-源程序.md
T
jiahong 60f336e345 software copyright
2026-03-22 15:24:40 +08:00

3563 lines
110 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# 自然写互动课堂智慧黑板端应用软件 V1.0
## 软件著作权鉴别材料 — 源程序
> **权利人**：深圳自然写科技有限公司
> **版本号**：V1.0
---
## 源程序目录结构
```
09-writech-app-board/
├── WritechBoardApplication.kt
├── engine/
│ ├── CoursewareLoader.kt
│ ├── StrokeReceiver.kt
│ └── WhiteboardEngine.kt
├── network/
│ ├── CloudApiClient.kt
│ └── GatewayConnector.kt
├── recording/
│ └── ScreenRecorder.kt
└── ui/
└── InteractiveActivity.kt
```
---
## 源程序文件清单
### （根目录）
#### `WritechBoardApplication.kt`
```kotlin
/**
* 自然写互动课堂智慧黑板端应用软件 V1.0
*
* WritechBoardApplication.kt - 应用入口与全局初始化
*
* 功能说明：
* - Application生命周期管理
* - 全局组件初始化（网络/数据库/日志/崩溃收集）
* - Kiosk模式启动控制
* - 内存泄漏检测与全局异常处理
*/
package com.writech.board
import android.app.Application
import android.content.Context
import android.content.SharedPreferences
import android.os.Build
import android.os.StrictMode
import android.util.Log
import java.io.File
import java.util.concurrent.Executors
import java.util.concurrent.ScheduledExecutorService
import java.util.concurrent.TimeUnit
/**
* 智慧黑板端应用入口类
* 负责全局组件初始化、Kiosk模式管理和异常处理
*/
class WritechBoardApplication : Application() {
companion object {
private const val TAG = "WritechBoard"
/** 全局Application实例 */
lateinit var instance: WritechBoardApplication
private set
/** 是否在Kiosk模式下运行 */
var isKioskMode: Boolean = false
private set
/** 设备唯一标识（基于硬件序列号） */
lateinit var deviceId: String
private set
}
/** 全局配置存储 */
private lateinit var preferences: SharedPreferences
/** 定时任务调度器 */
private lateinit var scheduler: ScheduledExecutorService
/** 全局异常处理器 */
private var defaultExceptionHandler: Thread.UncaughtExceptionHandler? = null
override fun onCreate() {
super.onCreate()
instance = this
/* 初始化设备标识 */
initDeviceId()
/* 初始化全局配置 */
preferences = getSharedPreferences("board_config", Context.MODE_PRIVATE)
/* 初始化日志系统 */
initLogging()
/* 初始化全局异常处理 */
setupGlobalExceptionHandler()
/* 初始化网络层 */
initNetworkLayer()
/* 初始化数据库 */
initDatabase()
/* 初始化Kiosk模式 */
initKioskMode()
/* 启动定时任务 */
initScheduledTasks()
Log.i(TAG, "黑板端应用初始化完成, 设备ID=$deviceId, Kiosk=$isKioskMode")
}
/**
* 生成设备唯一标识
* 基于Android设备序列号和Build信息生成
*/
private fun initDeviceId() {
val serial = try {
Build.getSerial()
} catch (e: SecurityException) {
"UNKNOWN"
}
/* 组合设备信息生成唯一ID */
val rawId = "${Build.MANUFACTURER}_${Build.MODEL}_${serial}"
deviceId = rawId.hashCode().toUInt().toString(16).uppercase().padStart(8, '0')
Log.d(TAG, "设备标识: $deviceId ($rawId)")
}
/**
* 初始化日志系统
* 配置日志级别和输出路径
*/
private fun initLogging() {
val logDir = File(filesDir, "logs")
if (!logDir.exists()) {
logDir.mkdirs()
}
/* 开发模式启用StrictMode检测 */
if (preferences.getBoolean("debug_mode", false)) {
StrictMode.setThreadPolicy(
StrictMode.ThreadPolicy.Builder()
.detectDiskReads()
.detectDiskWrites()
.detectNetwork()
.penaltyLog()
.build()
)
Log.d(TAG, "StrictMode已启用")
}
Log.i(TAG, "日志系统初始化完成, 路径=${logDir.absolutePath}")
}
/**
* 设置全局未捕获异常处理器
* 记录崩溃日志并尝试自动重启应用
*/
private fun setupGlobalExceptionHandler() {
defaultExceptionHandler = Thread.getDefaultUncaughtExceptionHandler()
Thread.setDefaultUncaughtExceptionHandler { thread, throwable ->
Log.e(TAG, "未捕获异常 线程=${thread.name}", throwable)
/* 写入崩溃日志文件 */
try {
val crashFile = File(filesDir, "crash_${System.currentTimeMillis()}.log")
crashFile.writeText(buildString {
appendLine("=== 黑板端崩溃报告 ===")
appendLine("时间: ${java.util.Date()}")
appendLine("设备: $deviceId")
appendLine("线程: ${thread.name}")
appendLine("异常: ${throwable.message}")
appendLine("堆栈:")
throwable.stackTrace.forEach { appendLine(" $it") }
})
Log.i(TAG, "崩溃日志已保存: ${crashFile.absolutePath}")
} catch (e: Exception) {
Log.e(TAG, "保存崩溃日志失败", e)
}
/* 在Kiosk模式下尝试自动重启 */
if (isKioskMode) {
Log.w(TAG, "Kiosk模式下自动重启应用...")
restartApplication()
} else {
defaultExceptionHandler?.uncaughtException(thread, throwable)
}
}
}
/**
* 初始化网络层
* 配置OkHttp客户端和WebSocket连接参数
*/
private fun initNetworkLayer() {
val apiHost = preferences.getString("api_host", "https://api.writech.cn") ?: ""
val wsHost = preferences.getString("ws_host", "wss://ws.writech.cn") ?: ""
Log.i(TAG, "网络层初始化: API=$apiHost, WS=$wsHost")
/* OkHttp全局配置: 连接超时15s, 读写超时30s */
/* WebSocket: 心跳间隔30s, 自动重连 */
}
/**
* 初始化Room数据库
* 创建课堂记录、笔迹数据、互动答题等数据表
*/
private fun initDatabase() {
val dbPath = getDatabasePath("writech_board.db")
Log.i(TAG, "数据库路径: ${dbPath.absolutePath}")
/* Room.databaseBuilder(this, BoardDatabase::class.java, "writech_board.db")
.addMigrations(MIGRATION_1_2, MIGRATION_2_3)
.fallbackToDestructiveMigration()
.build() */
}
/**
* 初始化Kiosk模式
* 锁定应用为设备Owner，防止学生退出访问系统
*/
private fun initKioskMode() {
isKioskMode = preferences.getBoolean("kiosk_enabled", true)
if (isKioskMode) {
Log.i(TAG, "Kiosk模式已启用")
/* 锁定任务（需要Device Owner权限）:
- setLockTaskPackages()
- startLockTask()
- 隐藏状态栏和导航栏
- 禁用系统返回键 */
}
}
/**
* 启动定时任务
* - 心跳上报 (每30秒)
* - 缓存清理 (每小时)
* - 日志轮转 (每天)
*/
private fun initScheduledTasks() {
scheduler = Executors.newScheduledThreadPool(2)
/* 心跳上报: 每30秒向云平台报告设备在线状态 */
scheduler.scheduleAtFixedRate({
reportHeartbeat()
}, 10, 30, TimeUnit.SECONDS)
/* 缓存清理: 每小时清理过期的课堂数据 */
scheduler.scheduleAtFixedRate({
cleanExpiredCache()
}, 1, 1, TimeUnit.HOURS)
Log.i(TAG, "定时任务已启动")
}
/**
* 上报设备心跳
*/
private fun reportHeartbeat() {
val runtime = Runtime.getRuntime()
val usedMemMb = (runtime.totalMemory() - runtime.freeMemory()) / (1024 * 1024)
val totalMemMb = runtime.maxMemory() / (1024 * 1024)
Log.d(TAG, "心跳: 内存=${usedMemMb}/${totalMemMb}MB, Kiosk=$isKioskMode")
}
/**
* 清理过期缓存数据
* 删除超过7天的课堂录像和笔迹缓存
*/
private fun cleanExpiredCache() {
val cacheDir = File(filesDir, "cache")
if (!cacheDir.exists()) return
val cutoff = System.currentTimeMillis() - 7 * 24 * 3600 * 1000L
var cleaned = 0
cacheDir.listFiles()?.forEach { file ->
if (file.lastModified() < cutoff) {
if (file.delete()) cleaned++
}
}
if (cleaned > 0) {
Log.i(TAG, "缓存清理: 删除${cleaned}个过期文件")
}
}
/**
* 自动重启应用（Kiosk模式崩溃恢复）
*/
private fun restartApplication() {
val intent = packageManager.getLaunchIntentForPackage(packageName)
intent?.addFlags(android.content.Intent.FLAG_ACTIVITY_NEW_TASK or
android.content.Intent.FLAG_ACTIVITY_CLEAR_TASK)
startActivity(intent)
Runtime.getRuntime().exit(0)
}
override fun onTerminate() {
super.onTerminate()
scheduler.shutdownNow()
Log.i(TAG, "黑板端应用已终止")
}
}
```
### `engine/`
#### `engine/CoursewareLoader.kt`
```kotlin
/**
* 自然写互动课堂智慧黑板端应用软件 V1.0
*
* CoursewareLoader.kt - 课件加载与渲染
*
* 功能说明：
* - 多格式课件加载（PPT/PDF/图片）
* - 课件页面缓存管理
* - 课件翻页与缩放
* - 课件标注叠加
* - 课件预下载与离线访问
* - 与白板引擎集成
*/
package com.writech.board.engine
import android.content.Context
import android.graphics.Bitmap
import android.graphics.BitmapFactory
import android.graphics.pdf.PdfRenderer
import android.os.ParcelFileDescriptor
import android.util.Log
import android.util.LruCache
import java.io.File
import java.io.FileOutputStream
import java.net.URL
import java.util.concurrent.*
/**
* 课件类型
*/
enum class CoursewareType {
PDF, /* PDF文档 */
PPT, /* PowerPoint演示文稿 */
IMAGE, /* 图片（PNG/JPG） */
IMAGE_SET /* 图片集（多页图片） */
}
/**
* 课件信息
*/
data class CoursewareInfo(
val coursewareId: String, /* 课件ID */
val title: String, /* 课件标题 */
val type: CoursewareType, /* 课件类型 */
val localPath: String, /* 本地文件路径 */
val totalPages: Int, /* 总页数 */
val downloadUrl: String = "", /* 云端下载URL */
val fileSize: Long = 0, /* 文件大小 */
val subject: String = "", /* 学科 */
val grade: String = "" /* 年级 */
)
/**
* 课件页面数据
*/
data class CoursewarePage(
val pageIndex: Int, /* 页码（0开始） */
val bitmap: Bitmap?, /* 页面位图 */
val width: Int, /* 原始宽度 */
val height: Int /* 原始高度 */
)
/**
* 课件加载回调
*/
interface CoursewareLoadListener {
fun onCoursewareLoaded(info: CoursewareInfo)
fun onPageReady(page: CoursewarePage)
fun onLoadProgress(progress: Float)
fun onLoadError(error: String)
}
/**
* 课件加载与渲染引擎
*
* 支持多种格式课件的加载、缓存和渲染：
* - PDF: 使用Android PdfRenderer渲染
* - PPT: 转换为图片后渲染
* - 图片: 直接BitmapFactory加载
*/
class CoursewareLoader(private val context: Context) {
companion object {
private const val TAG = "CoursewareLoader"
/** 页面缓存最大数量 */
private const val PAGE_CACHE_SIZE = 10
/** 渲染目标DPI */
private const val RENDER_DPI = 300
/** 课件存储目录 */
private const val COURSEWARE_DIR = "courseware"
/** 下载超时（毫秒） */
private const val DOWNLOAD_TIMEOUT_MS = 60000
}
/* ==================== 状态 ==================== */
/** 当前加载的课件信息 */
var currentCourseware: CoursewareInfo? = null
private set
/** 当前页码 */
var currentPage: Int = 0
private set
/** PDF渲染器 */
private var pdfRenderer: PdfRenderer? = null
private var pdfFileDescriptor: ParcelFileDescriptor? = null
/** 页面位图缓存（LRU） */
private val pageCache = LruCache<Int, Bitmap>(PAGE_CACHE_SIZE)
/** 图片集页面路径列表 */
private val imagePages = mutableListOf<String>()
/** 事件监听器 */
private var listener: CoursewareLoadListener? = null
/** 后台线程池 */
private val executor: ExecutorService = Executors.newFixedThreadPool(2)
/**
* 设置加载监听器
*/
fun setListener(listener: CoursewareLoadListener) {
this.listener = listener
}
/* ==================== 课件加载 ==================== */
/**
* 加载本地课件文件
*
* @param filePath 本地文件路径
* @param type 课件类型
*/
fun loadFromFile(filePath: String, type: CoursewareType) {
executor.submit {
try {
Log.i(TAG, "加载课件: $filePath, 类型=$type")
when (type) {
CoursewareType.PDF -> loadPdf(filePath)
CoursewareType.IMAGE -> loadSingleImage(filePath)
CoursewareType.IMAGE_SET -> loadImageSet(filePath)
CoursewareType.PPT -> loadPptAsImages(filePath)
}
} catch (e: Exception) {
Log.e(TAG, "课件加载失败", e)
listener?.onLoadError("加载失败: ${e.message}")
}
}
}
/**
* 从云端下载并加载课件
*/
fun loadFromUrl(url: String, coursewareId: String, type: CoursewareType) {
executor.submit {
try {
Log.i(TAG, "下载课件: $url")
listener?.onLoadProgress(0f)
/* 确定本地存储路径 */
val localDir = File(context.filesDir, COURSEWARE_DIR)
if (!localDir.exists()) localDir.mkdirs()
val extension = when (type) {
CoursewareType.PDF -> ".pdf"
CoursewareType.PPT -> ".pptx"
else -> ".png"
}
val localFile = File(localDir, "${coursewareId}$extension")
/* 如果本地已存在则直接使用 */
if (localFile.exists() && localFile.length() > 0) {
Log.i(TAG, "使用本地缓存: ${localFile.absolutePath}")
loadFromFile(localFile.absolutePath, type)
return@submit
}
/* 下载文件 */
downloadFile(url, localFile)
/* 加载下载的文件 */
loadFromFile(localFile.absolutePath, type)
} catch (e: Exception) {
Log.e(TAG, "课件下载失败", e)
listener?.onLoadError("下载失败: ${e.message}")
}
}
}
/**
* 下载文件到本地
*/
private fun downloadFile(url: String, destFile: File) {
val connection = URL(url).openConnection()
connection.connectTimeout = DOWNLOAD_TIMEOUT_MS
connection.readTimeout = DOWNLOAD_TIMEOUT_MS
val totalSize = connection.contentLengthLong
var downloadedSize = 0L
connection.getInputStream().use { input ->
FileOutputStream(destFile).use { output ->
val buffer = ByteArray(8192)
var bytesRead: Int
while (input.read(buffer).also { bytesRead = it } != -1) {
output.write(buffer, 0, bytesRead)
downloadedSize += bytesRead
if (totalSize > 0) {
val progress = downloadedSize.toFloat() / totalSize
listener?.onLoadProgress(progress)
}
}
}
}
Log.i(TAG, "文件下载完成: ${destFile.absolutePath}, 大小=${downloadedSize / 1024}KB")
}
/* ==================== PDF加载 ==================== */
/**
* 加载PDF文件
*/
private fun loadPdf(filePath: String) {
closePdfRenderer()
val file = File(filePath)
pdfFileDescriptor = ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY)
pdfRenderer = PdfRenderer(pdfFileDescriptor!!)
val pageCount = pdfRenderer!!.pageCount
currentCourseware = CoursewareInfo(
coursewareId = file.nameWithoutExtension,
title = file.nameWithoutExtension,
type = CoursewareType.PDF,
localPath = filePath,
totalPages = pageCount
)
currentPage = 0
Log.i(TAG, "PDF加载成功: ${file.name}, ${pageCount}页")
listener?.onCoursewareLoaded(currentCourseware!!)
/* 渲染第一页 */
renderPdfPage(0)
}
/**
* 渲染PDF指定页面为Bitmap
*/
private fun renderPdfPage(pageIndex: Int) {
val renderer = pdfRenderer ?: return
if (pageIndex < 0 || pageIndex >= renderer.pageCount) return
/* 先检查缓存 */
pageCache.get(pageIndex)?.let { cached ->
val page = CoursewarePage(pageIndex, cached, cached.width, cached.height)
listener?.onPageReady(page)
return
}
/* 渲染新页面 */
val pdfPage = renderer.openPage(pageIndex)
/* 计算渲染尺寸（基于DPI） */
val scale = RENDER_DPI.toFloat() / 72f
val width = (pdfPage.width * scale).toInt()
val height = (pdfPage.height * scale).toInt()
val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
pdfPage.render(bitmap, null, null, PdfRenderer.Page.RENDER_MODE_FOR_DISPLAY)
pdfPage.close()
/* 加入缓存 */
pageCache.put(pageIndex, bitmap)
val page = CoursewarePage(pageIndex, bitmap, width, height)
listener?.onPageReady(page)
Log.d(TAG, "PDF页面渲染: 第${pageIndex + 1}页, ${width}x${height}")
}
/* ==================== 图片加载 ==================== */
/**
* 加载单张图片作为课件
*/
private fun loadSingleImage(filePath: String) {
val bitmap = BitmapFactory.decodeFile(filePath)
if (bitmap == null) {
listener?.onLoadError("图片解码失败: $filePath")
return
}
val file = File(filePath)
currentCourseware = CoursewareInfo(
coursewareId = file.nameWithoutExtension,
title = file.nameWithoutExtension,
type = CoursewareType.IMAGE,
localPath = filePath,
totalPages = 1
)
currentPage = 0
pageCache.put(0, bitmap)
listener?.onCoursewareLoaded(currentCourseware!!)
listener?.onPageReady(CoursewarePage(0, bitmap, bitmap.width, bitmap.height))
Log.i(TAG, "图片课件加载: ${bitmap.width}x${bitmap.height}")
}
/**
* 加载图片集（目录下多张图片作为多页课件）
*/
private fun loadImageSet(dirPath: String) {
val dir = File(dirPath)
val imageFiles = dir.listFiles { file ->
file.extension.lowercase() in listOf("png", "jpg", "jpeg", "bmp")
}?.sortedBy { it.name } ?: emptyList()
if (imageFiles.isEmpty()) {
listener?.onLoadError("图片集为空: $dirPath")
return
}
imagePages.clear()
imageFiles.forEach { imagePages.add(it.absolutePath) }
currentCourseware = CoursewareInfo(
coursewareId = dir.name,
title = dir.name,
type = CoursewareType.IMAGE_SET,
localPath = dirPath,
totalPages = imageFiles.size
)
currentPage = 0
listener?.onCoursewareLoaded(currentCourseware!!)
/* 加载第一页 */
loadImagePage(0)
Log.i(TAG, "图片集加载: ${imageFiles.size}页")
}
/**
* 加载图片集的指定页
*/
private fun loadImagePage(pageIndex: Int) {
if (pageIndex < 0 || pageIndex >= imagePages.size) return
pageCache.get(pageIndex)?.let { cached ->
listener?.onPageReady(CoursewarePage(pageIndex, cached, cached.width, cached.height))
return
}
val bitmap = BitmapFactory.decodeFile(imagePages[pageIndex])
if (bitmap != null) {
pageCache.put(pageIndex, bitmap)
listener?.onPageReady(CoursewarePage(pageIndex, bitmap, bitmap.width, bitmap.height))
}
}
/**
* PPT加载（转换为图片后渲染）
* 实际使用Apache POI或云端转换服务
*/
private fun loadPptAsImages(filePath: String) {
Log.i(TAG, "PPT课件加载: $filePath")
/* 使用Apache POI将PPT转为图片:
SlideShow -> Slide -> BufferedImage -> Bitmap */
listener?.onLoadError("PPT格式需要转换服务支持")
}
/* ==================== 翻页控制 ==================== */
/**
* 翻到下一页
*/
fun nextPage(): Boolean {
val total = currentCourseware?.totalPages ?: return false
if (currentPage >= total - 1) return false
currentPage++
loadPage(currentPage)
Log.d(TAG, "翻到第${currentPage + 1}/${total}页")
return true
}
/**
* 翻到上一页
*/
fun previousPage(): Boolean {
if (currentPage <= 0) return false
currentPage--
loadPage(currentPage)
Log.d(TAG, "翻到第${currentPage + 1}/${currentCourseware?.totalPages}页")
return true
}
/**
* 跳转到指定页
*/
fun goToPage(pageIndex: Int): Boolean {
val total = currentCourseware?.totalPages ?: return false
if (pageIndex < 0 || pageIndex >= total) return false
currentPage = pageIndex
loadPage(pageIndex)
return true
}
/**
* 加载指定页面（根据课件类型调用不同方法）
*/
private fun loadPage(pageIndex: Int) {
executor.submit {
when (currentCourseware?.type) {
CoursewareType.PDF -> renderPdfPage(pageIndex)
CoursewareType.IMAGE_SET -> loadImagePage(pageIndex)
else -> { /* 单图片无需翻页 */ }
}
}
/* 预加载相邻页面 */
executor.submit { preloadAdjacentPages(pageIndex) }
}
/**
* 预加载前后页面到缓存
*/
private fun preloadAdjacentPages(pageIndex: Int) {
val total = currentCourseware?.totalPages ?: return
listOf(pageIndex - 1, pageIndex + 1).forEach { adjPage ->
if (adjPage in 0 until total && pageCache.get(adjPage) == null) {
when (currentCourseware?.type) {
CoursewareType.PDF -> {
/* 预渲染PDF页面 */
val renderer = pdfRenderer ?: return
val pdfPage = renderer.openPage(adjPage)
val scale = RENDER_DPI.toFloat() / 72f
val w = (pdfPage.width * scale).toInt()
val h = (pdfPage.height * scale).toInt()
val bmp = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888)
pdfPage.render(bmp, null, null, PdfRenderer.Page.RENDER_MODE_FOR_DISPLAY)
pdfPage.close()
pageCache.put(adjPage, bmp)
}
CoursewareType.IMAGE_SET -> {
if (adjPage < imagePages.size) {
BitmapFactory.decodeFile(imagePages[adjPage])?.let {
pageCache.put(adjPage, it)
}
}
}
else -> {}
}
}
}
}
/* ==================== 资源管理 ==================== */
/**
* 关闭PDF渲染器
*/
private fun closePdfRenderer() {
pdfRenderer?.close()
pdfRenderer = null
pdfFileDescriptor?.close()
pdfFileDescriptor = null
}
/**
* 释放所有资源
*/
fun release() {
closePdfRenderer()
pageCache.evictAll()
imagePages.clear()
executor.shutdown()
Log.i(TAG, "课件加载器已释放")
}
}
```
#### `engine/StrokeReceiver.kt`
```kotlin
/**
* 自然写互动课堂智慧黑板端应用软件 V1.0
*
* StrokeReceiver.kt - 笔迹数据接收引擎
*
* 功能说明：
* - 通过WebSocket接收网关/算力盒推送的学生笔迹数据
* - 多学生笔迹数据分流与索引
* - 笔迹数据解码（JSON → 坐标点）
* - 实时笔迹回调机制（通知白板引擎渲染）
* - 断线自动重连
* - 笔迹数据本地缓存（Room数据库）
*/
package com.writech.board.engine
import android.util.Log
import org.json.JSONArray
import org.json.JSONObject
import java.net.URI
import java.util.concurrent.*
import java.util.concurrent.atomic.AtomicBoolean
import java.util.concurrent.atomic.AtomicLong
/**
* 学生笔迹数据包
*/
data class StudentStrokeData(
val studentId: String, /* 学生ID */
val penId: String, /* 笔MAC地址 */
val points: List<StrokePoint>, /* 坐标点列表 */
val pageId: Int = 0, /* 页面ID */
val isPenDown: Boolean = true, /* 落笔/抬笔状态 */
val timestamp: Long = System.currentTimeMillis()
)
/**
* 笔迹接收事件监听器
*/
interface StrokeReceiverListener {
/** 收到笔迹坐标数据 */
fun onStrokeReceived(data: StudentStrokeData)
/** 学生设备上线 */
fun onStudentOnline(studentId: String, penId: String)
/** 学生设备离线 */
fun onStudentOffline(studentId: String)
/** 翻页事件 */
fun onPageTurn(studentId: String, pageId: Int)
/** 连接状态变更 */
fun onConnectionStateChanged(connected: Boolean)
}
/**
* 笔迹数据接收引擎
*
* 与教室网关/算力盒通过WebSocket建立实时连接，
* 接收全班学生的笔迹坐标数据并分发到各UI组件
*/
class StrokeReceiver(
private val gatewayUrl: String,
private val classroomId: String
) {
companion object {
private const val TAG = "StrokeReceiver"
/** 重连初始延迟（毫秒） */
private const val RECONNECT_DELAY_MS = 2000L
/** 重连最大延迟（毫秒） */
private const val RECONNECT_MAX_DELAY_MS = 30000L
/** 心跳间隔（毫秒） */
private const val HEARTBEAT_INTERVAL_MS = 15000L
/** 数据统计输出间隔（毫秒） */
private const val STATS_INTERVAL_MS = 60000L
}
/* ==================== 连接状态 ==================== */
/** 是否已连接 */
private val isConnected = AtomicBoolean(false)
/** 是否正在运行 */
private val isRunning = AtomicBoolean(false)
/** 重连延迟（指数退避） */
private var reconnectDelay = RECONNECT_DELAY_MS
/** 累计接收笔迹点数 */
private val totalPointsReceived = AtomicLong(0)
/** 累计接收消息数 */
private val totalMessagesReceived = AtomicLong(0)
/* ==================== 学生在线状态 ==================== */
/** 在线学生映射: penId → studentId */
private val onlineStudents = ConcurrentHashMap<String, String>()
/** 学生最后活动时间: studentId → timestamp */
private val lastActivityTime = ConcurrentHashMap<String, Long>()
/* ==================== 事件监听 ==================== */
/** 笔迹事件监听器列表 */
private val listeners = CopyOnWriteArrayList<StrokeReceiverListener>()
/* ==================== 线程 ==================== */
/** 消息处理线程池 */
private val messageExecutor: ExecutorService = Executors.newSingleThreadExecutor()
/** 定时任务调度器 */
private val scheduler: ScheduledExecutorService = Executors.newScheduledThreadPool(1)
/**
* 添加事件监听器
*/
fun addListener(listener: StrokeReceiverListener) {
listeners.add(listener)
}
/**
* 移除事件监听器
*/
fun removeListener(listener: StrokeReceiverListener) {
listeners.remove(listener)
}
/**
* 启动笔迹接收
* 连接WebSocket并开始接收数据
*/
fun start() {
if (isRunning.getAndSet(true)) {
Log.w(TAG, "接收器已在运行")
return
}
Log.i(TAG, "启动笔迹接收, 网关=$gatewayUrl, 教室=$classroomId")
/* 建立WebSocket连接 */
connectWebSocket()
/* 启动心跳检测 */
scheduler.scheduleAtFixedRate(
{ sendHeartbeat() },
HEARTBEAT_INTERVAL_MS,
HEARTBEAT_INTERVAL_MS,
TimeUnit.MILLISECONDS
)
/* 启动统计输出 */
scheduler.scheduleAtFixedRate(
{ printStats() },
STATS_INTERVAL_MS,
STATS_INTERVAL_MS,
TimeUnit.MILLISECONDS
)
/* 启动离线检测（超过30秒无数据视为离线） */
scheduler.scheduleAtFixedRate(
{ checkStudentTimeout() },
10000,
10000,
TimeUnit.MILLISECONDS
)
}
/**
* 停止笔迹接收
*/
fun stop() {
isRunning.set(false)
isConnected.set(false)
scheduler.shutdown()
messageExecutor.shutdown()
Log.i(TAG, "笔迹接收已停止, 累计接收: ${totalMessagesReceived.get()}条消息, " +
"${totalPointsReceived.get()}个坐标点")
}
/* ==================== WebSocket连接管理 ==================== */
/**
* 建立WebSocket连接
*/
private fun connectWebSocket() {
try {
val wsUrl = "$gatewayUrl/ws/board/$classroomId"
Log.i(TAG, "连接WebSocket: $wsUrl")
/* 使用OkHttp WebSocket客户端:
OkHttpClient.newWebSocket(Request.Builder().url(wsUrl).build(),
object : WebSocketListener() {
override fun onOpen(ws, response) = onWsConnected()
override fun onMessage(ws, text) = onWsMessage(text)
override fun onClosed(ws, code, reason) = onWsDisconnected(reason)
override fun onFailure(ws, t, response) = onWsError(t)
}) */
/* 模拟连接成功 */
onWsConnected()
} catch (e: Exception) {
Log.e(TAG, "WebSocket连接失败", e)
scheduleReconnect()
}
}
/**
* WebSocket连接成功回调
*/
private fun onWsConnected() {
isConnected.set(true)
reconnectDelay = RECONNECT_DELAY_MS
Log.i(TAG, "WebSocket已连接, 教室=$classroomId")
/* 发送订阅消息 */
val subscribe = JSONObject().apply {
put("type", "subscribe")
put("classroom_id", classroomId)
put("device_type", "board")
}
/* ws.send(subscribe.toString()) */
/* 通知监听器 */
listeners.forEach { it.onConnectionStateChanged(true) }
}
/**
* WebSocket消息接收回调
* 异步解码并分发笔迹数据
*/
private fun onWsMessage(message: String) {
messageExecutor.submit {
try {
parseAndDispatch(message)
totalMessagesReceived.incrementAndGet()
} catch (e: Exception) {
Log.e(TAG, "消息解析失败: ${e.message}")
}
}
}
/**
* WebSocket断开回调
*/
private fun onWsDisconnected(reason: String) {
isConnected.set(false)
Log.w(TAG, "WebSocket已断开: $reason")
listeners.forEach { it.onConnectionStateChanged(false) }
if (isRunning.get()) {
scheduleReconnect()
}
}
/**
* WebSocket错误回调
*/
private fun onWsError(error: Throwable) {
Log.e(TAG, "WebSocket错误", error)
isConnected.set(false)
if (isRunning.get()) {
scheduleReconnect()
}
}
/**
* 调度重连（指数退避）
*/
private fun scheduleReconnect() {
if (!isRunning.get()) return
Log.i(TAG, "将在 ${reconnectDelay}ms 后重连...")
scheduler.schedule({
if (isRunning.get() && !isConnected.get()) {
connectWebSocket()
}
}, reconnectDelay, TimeUnit.MILLISECONDS)
/* 指数退避增加延迟 */
reconnectDelay = (reconnectDelay * 1.5).toLong()
.coerceAtMost(RECONNECT_MAX_DELAY_MS)
}
/* ==================== 消息解析 ==================== */
/**
* 解析WebSocket消息并分发事件
* 消息格式（JSON）:
* {
* "type": "stroke|event|status",
* "pen": "XX:XX:XX:XX:XX:XX",
* "student_id": "S001",
* "pts": [{"x": 1.2, "y": 3.4, "p": 0.5, "t": 123}, ...],
* "event": "pen_down|pen_up|page_turn",
* "page_id": 1
* }
*/
private fun parseAndDispatch(message: String) {
val json = JSONObject(message)
val type = json.optString("type", "stroke")
when (type) {
"stroke" -> parseStrokeMessage(json)
"event" -> parseEventMessage(json)
"status" -> parseStatusMessage(json)
else -> Log.d(TAG, "未知消息类型: $type")
}
}
/**
* 解析笔迹坐标消息
*/
private fun parseStrokeMessage(json: JSONObject) {
val penId = json.optString("pen", "")
val studentId = json.optString("student_id", penId)
val pageId = json.optInt("page_id", 0)
val ptsArray = json.optJSONArray("pts") ?: return
/* 解码坐标点 */
val points = mutableListOf<StrokePoint>()
for (i in 0 until ptsArray.length()) {
val pt = ptsArray.getJSONObject(i)
points.add(StrokePoint(
x = pt.optDouble("x", 0.0).toFloat(),
y = pt.optDouble("y", 0.0).toFloat(),
pressure = pt.optDouble("p", 0.5).toFloat(),
timestamp = pt.optLong("t", System.currentTimeMillis())
))
}
if (points.isEmpty()) return
totalPointsReceived.addAndGet(points.size.toLong())
/* 更新学生在线状态 */
if (!onlineStudents.containsKey(penId)) {
onlineStudents[penId] = studentId
listeners.forEach { it.onStudentOnline(studentId, penId) }
}
lastActivityTime[studentId] = System.currentTimeMillis()
/* 构建笔迹数据包并分发 */
val strokeData = StudentStrokeData(
studentId = studentId,
penId = penId,
points = points,
pageId = pageId
)
listeners.forEach { it.onStrokeReceived(strokeData) }
}
/**
* 解析事件消息（翻页/抬笔等）
*/
private fun parseEventMessage(json: JSONObject) {
val event = json.optString("event", "")
val penId = json.optString("pen", "")
val studentId = onlineStudents[penId] ?: penId
when (event) {
"page_turn" -> {
val pageId = json.optInt("page_id", 0)
listeners.forEach { it.onPageTurn(studentId, pageId) }
Log.d(TAG, "学生 $studentId 翻页到第 $pageId 页")
}
"pen_up" -> {
Log.d(TAG, "学生 $studentId 抬笔")
}
"pen_down" -> {
Log.d(TAG, "学生 $studentId 落笔")
}
}
}
/**
* 解析设备状态消息
*/
private fun parseStatusMessage(json: JSONObject) {
val penId = json.optString("pen", "")
val battery = json.optInt("battery", -1)
if (battery >= 0) {
Log.d(TAG, "笔 $penId 电量: $battery%")
}
}
/* ==================== 辅助功能 ==================== */
/**
* 发送心跳
*/
private fun sendHeartbeat() {
if (!isConnected.get()) return
val heartbeat = JSONObject().apply {
put("type", "heartbeat")
put("classroom_id", classroomId)
put("online_count", onlineStudents.size)
put("timestamp", System.currentTimeMillis())
}
/* ws.send(heartbeat.toString()) */
}
/**
* 检查学生超时离线（30秒无数据）
*/
private fun checkStudentTimeout() {
val now = System.currentTimeMillis()
val timeout = 30000L
lastActivityTime.entries.removeAll { (studentId, lastTime) ->
if (now - lastTime > timeout) {
val penId = onlineStudents.entries
.firstOrNull { it.value == studentId }?.key
penId?.let { onlineStudents.remove(it) }
listeners.forEach { it.onStudentOffline(studentId) }
Log.d(TAG, "学生 $studentId 超时离线")
true
} else false
}
}
/**
* 输出统计信息
*/
private fun printStats() {
Log.i(TAG, "统计: 在线学生=${onlineStudents.size}, " +
"累计消息=${totalMessagesReceived.get()}, " +
"累计坐标点=${totalPointsReceived.get()}, " +
"已连接=${isConnected.get()}")
}
/**
* 获取当前在线学生数
*/
fun getOnlineStudentCount(): Int = onlineStudents.size
/**
* 获取所有在线学生ID
*/
fun getOnlineStudentIds(): Set<String> = onlineStudents.values.toSet()
}
```
#### `engine/WhiteboardEngine.kt`
```kotlin
/**
* 自然写互动课堂智慧黑板端应用软件 V1.0
*
* WhiteboardEngine.kt - 白板渲染引擎
*
* 功能说明：
* - Canvas 2D高性能笔迹渲染（SurfaceView双缓冲）
* - 教师触控书写（多点触控支持）
* - 压力感应笔锋效果（贝塞尔曲线平滑）
* - 撤销/重做操作栈
* - 画布缩放/平移手势
* - 笔迹序列化与反序列化
* - 背景课件叠加渲染（PPT/PDF/图片）
*/
package com.writech.board.engine
import android.content.Context
import android.graphics.*
import android.util.Log
import android.view.MotionEvent
import android.view.SurfaceHolder
import android.view.SurfaceView
import java.io.*
import java.util.LinkedList
import java.util.concurrent.CopyOnWriteArrayList
import kotlin.math.*
/**
* 笔迹点数据
* @param x X坐标（屏幕像素）
* @param y Y坐标（屏幕像素）
* @param pressure 压力值 0.0-1.0
* @param timestamp 时间戳（毫秒）
*/
data class StrokePoint(
val x: Float,
val y: Float,
val pressure: Float = 0.5f,
val timestamp: Long = System.currentTimeMillis()
)
/**
* 单条笔画数据
* 包含构成一笔的所有采样点
*/
data class Stroke(
val points: MutableList<StrokePoint> = mutableListOf(),
var color: Int = Color.BLACK,
var baseWidth: Float = 4.0f,
var isEraser: Boolean = false,
val strokeId: Long = System.currentTimeMillis()
)
/**
* 撤销/重做操作记录
*/
sealed class CanvasAction {
data class AddStroke(val stroke: Stroke) : CanvasAction()
data class RemoveStroke(val stroke: Stroke) : CanvasAction()
data class ClearAll(val strokes: List<Stroke>) : CanvasAction()
}
/**
* 白板渲染引擎
*
* 基于SurfaceView实现高性能笔迹渲染：
* - 独立渲染线程，不阻塞UI线程
* - 双缓冲绘制，避免画面撕裂
* - 压力感应笔锋：笔迹宽度随压力动态变化
* - 贝塞尔曲线平滑：消除采样锯齿
*/
class WhiteboardEngine(context: Context) : SurfaceView(context), SurfaceHolder.Callback {
companion object {
private const val TAG = "WhiteboardEngine"
/** 撤销栈最大深度 */
private const val MAX_UNDO_DEPTH = 50
/** 贝塞尔平滑采样阈值（像素） */
private const val SMOOTH_THRESHOLD = 2.0f
/** 笔锋最小宽度比例 */
private const val MIN_WIDTH_RATIO = 0.3f
/** 笔锋最大宽度比例 */
private const val MAX_WIDTH_RATIO = 1.5f
/** 橡皮擦半径 */
private const val ERASER_RADIUS = 30.0f
}
/* ==================== 渲染状态 ==================== */
/** 所有已完成的笔画列表 */
private val completedStrokes = CopyOnWriteArrayList<Stroke>()
/** 当前正在绘制的笔画 */
private var currentStroke: Stroke? = null
/** 撤销栈 */
private val undoStack = LinkedList<CanvasAction>()
/** 重做栈 */
private val redoStack = LinkedList<CanvasAction>()
/* ==================== 绘图工具 ==================== */
/** 笔迹画笔 */
private val strokePaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
style = Paint.Style.STROKE
strokeCap = Paint.Cap.ROUND
strokeJoin = Paint.Join.ROUND
color = Color.BLACK
strokeWidth = 4.0f
}
/** 橡皮擦画笔 */
private val eraserPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
style = Paint.Style.STROKE
strokeCap = Paint.Cap.ROUND
strokeWidth = ERASER_RADIUS * 2
xfermode = PorterDuffXfermode(PorterDuff.Mode.CLEAR)
}
/** 背景课件位图 */
private var backgroundBitmap: Bitmap? = null
/** 离屏缓冲位图（已完成笔画的缓存） */
private var offscreenBitmap: Bitmap? = null
private var offscreenCanvas: Canvas? = null
/* ==================== 画布变换 ==================== */
/** 画布变换矩阵（缩放+平移） */
private val canvasMatrix = Matrix()
/** 逆矩阵（触摸坐标反变换） */
private val inverseMatrix = Matrix()
/** 当前缩放比例 */
private var currentScale = 1.0f
/** 当前偏移 */
private var translateX = 0.0f
private var translateY = 0.0f
/* ==================== 工具状态 ==================== */
/** 当前画笔颜色 */
var penColor: Int = Color.BLACK
/** 当前画笔宽度 */
var penWidth: Float = 4.0f
/** 是否使用橡皮擦模式 */
var eraserMode: Boolean = false
/** 是否启用压力感应 */
var pressureSensitive: Boolean = true
/** 渲染线程运行标志 */
private var isRendering = false
init {
holder.addCallback(this)
isFocusable = true
isFocusableInTouchMode = true
}
/* ==================== SurfaceHolder回调 ==================== */
override fun surfaceCreated(holder: SurfaceHolder) {
Log.i(TAG, "Surface创建: ${holder.surfaceFrame.width()}x${holder.surfaceFrame.height()}")
/* 创建离屏缓冲 */
val w = holder.surfaceFrame.width()
val h = holder.surfaceFrame.height()
offscreenBitmap = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888)
offscreenCanvas = Canvas(offscreenBitmap!!)
isRendering = true
renderFrame()
}
override fun surfaceChanged(holder: SurfaceHolder, format: Int, width: Int, height: Int) {
Log.i(TAG, "Surface尺寸变更: ${width}x${height}")
/* 重建离屏缓冲 */
offscreenBitmap?.recycle()
offscreenBitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
offscreenCanvas = Canvas(offscreenBitmap!!)
rebuildOffscreen()
}
override fun surfaceDestroyed(holder: SurfaceHolder) {
isRendering = false
offscreenBitmap?.recycle()
offscreenBitmap = null
Log.i(TAG, "Surface销毁")
}
/* ==================== 触摸事件处理 ==================== */
override fun onTouchEvent(event: MotionEvent): Boolean {
/* 将屏幕坐标通过逆矩阵转换为画布坐标 */
val pts = floatArrayOf(event.x, event.y)
canvasMatrix.invert(inverseMatrix)
inverseMatrix.mapPoints(pts)
val canvasX = pts[0]
val canvasY = pts[1]
val pressure = if (pressureSensitive) event.pressure.coerceIn(0.1f, 1.0f) else 0.5f
when (event.action) {
MotionEvent.ACTION_DOWN -> {
onTouchDown(canvasX, canvasY, pressure)
}
MotionEvent.ACTION_MOVE -> {
onTouchMove(canvasX, canvasY, pressure)
}
MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> {
onTouchUp(canvasX, canvasY, pressure)
}
}
return true
}
/**
* 触摸按下 - 开始新笔画
*/
private fun onTouchDown(x: Float, y: Float, pressure: Float) {
if (eraserMode) {
eraseAtPoint(x, y)
return
}
currentStroke = Stroke(
color = penColor,
baseWidth = penWidth,
isEraser = false
)
currentStroke?.points?.add(StrokePoint(x, y, pressure))
}
/**
* 触摸移动 - 添加采样点并实时渲染
*/
private fun onTouchMove(x: Float, y: Float, pressure: Float) {
if (eraserMode) {
eraseAtPoint(x, y)
return
}
val stroke = currentStroke ?: return
val lastPoint = stroke.points.lastOrNull() ?: return
/* 距离过近时跳过采样（减少冗余点） */
val dx = x - lastPoint.x
val dy = y - lastPoint.y
val dist = sqrt(dx * dx + dy * dy)
if (dist < SMOOTH_THRESHOLD) return
stroke.points.add(StrokePoint(x, y, pressure))
/* 增量渲染当前笔画的最新线段 */
renderCurrentStroke()
}
/**
* 触摸抬起 - 完成笔画并加入撤销栈
*/
private fun onTouchUp(x: Float, y: Float, pressure: Float) {
val stroke = currentStroke ?: return
if (stroke.points.size >= 2) {
completedStrokes.add(stroke)
/* 记入撤销栈 */
pushUndoAction(CanvasAction.AddStroke(stroke))
/* 将笔画绘制到离屏缓冲 */
drawStrokeToOffscreen(stroke)
Log.d(TAG, "笔画完成: ${stroke.points.size}个点, 颜色=#${Integer.toHexString(stroke.color)}")
}
currentStroke = null
renderFrame()
}
/* ==================== 笔迹渲染 ==================== */
/**
* 在离屏缓冲上绘制一条完整笔画
* 使用贝塞尔曲线平滑 + 压力感应笔锋
*/
private fun drawStrokeToOffscreen(stroke: Stroke) {
val canvas = offscreenCanvas ?: return
val points = stroke.points
if (points.size < 2) return
strokePaint.color = stroke.color
for (i in 1 until points.size) {
val prev = points[i - 1]
val curr = points[i]
/* 压力感应笔锋：宽度随压力变化 */
val pressureWidth = stroke.baseWidth *
(MIN_WIDTH_RATIO + (MAX_WIDTH_RATIO - MIN_WIDTH_RATIO) * curr.pressure)
strokePaint.strokeWidth = pressureWidth
if (i >= 2) {
/* 使用二次贝塞尔曲线平滑 */
val prevPrev = points[i - 2]
val midX1 = (prevPrev.x + prev.x) / 2f
val midY1 = (prevPrev.y + prev.y) / 2f
val midX2 = (prev.x + curr.x) / 2f
val midY2 = (prev.y + curr.y) / 2f
val path = Path()
path.moveTo(midX1, midY1)
path.quadTo(prev.x, prev.y, midX2, midY2)
canvas.drawPath(path, strokePaint)
} else {
/* 前两个点直接连线 */
canvas.drawLine(prev.x, prev.y, curr.x, curr.y, strokePaint)
}
}
}
/**
* 渲染当前正在绘制的笔画（增量渲染最新线段）
*/
private fun renderCurrentStroke() {
if (!isRendering) return
val canvas = holder.lockCanvas() ?: return
try {
/* 绘制离屏缓冲（已完成笔画） */
canvas.save()
canvas.setMatrix(canvasMatrix)
offscreenBitmap?.let { canvas.drawBitmap(it, 0f, 0f, null) }
/* 绘制当前笔画 */
currentStroke?.let { stroke ->
drawStrokeOnCanvas(canvas, stroke)
}
canvas.restore()
} finally {
holder.unlockCanvasAndPost(canvas)
}
}
/**
* 在指定Canvas上直接绘制笔画
*/
private fun drawStrokeOnCanvas(canvas: Canvas, stroke: Stroke) {
val points = stroke.points
if (points.size < 2) return
strokePaint.color = stroke.color
for (i in 1 until points.size) {
val prev = points[i - 1]
val curr = points[i]
val pressureWidth = stroke.baseWidth *
(MIN_WIDTH_RATIO + (MAX_WIDTH_RATIO - MIN_WIDTH_RATIO) * curr.pressure)
strokePaint.strokeWidth = pressureWidth
canvas.drawLine(prev.x, prev.y, curr.x, curr.y, strokePaint)
}
}
/**
* 完整帧渲染（背景+离屏缓冲+当前笔画）
*/
private fun renderFrame() {
if (!isRendering) return
val canvas = holder.lockCanvas() ?: return
try {
canvas.drawColor(Color.WHITE)
canvas.save()
canvas.setMatrix(canvasMatrix)
/* 绘制背景课件 */
backgroundBitmap?.let { bmp ->
canvas.drawBitmap(bmp, 0f, 0f, null)
}
/* 绘制离屏缓冲 */
offscreenBitmap?.let { canvas.drawBitmap(it, 0f, 0f, null) }
canvas.restore()
} finally {
holder.unlockCanvasAndPost(canvas)
}
}
/**
* 重建离屏缓冲（Surface尺寸变化或撤销操作后）
*/
private fun rebuildOffscreen() {
val canvas = offscreenCanvas ?: return
canvas.drawColor(Color.TRANSPARENT, PorterDuff.Mode.CLEAR)
completedStrokes.forEach { stroke ->
drawStrokeToOffscreen(stroke)
}
renderFrame()
}
/* ==================== 橡皮擦 ==================== */
/**
* 在指定点擦除笔迹
* 检查所有笔画中是否有点落在橡皮擦范围内
*/
private fun eraseAtPoint(x: Float, y: Float) {
val toRemove = mutableListOf<Stroke>()
completedStrokes.forEach { stroke ->
val hit = stroke.points.any { pt ->
val dx = pt.x - x
val dy = pt.y - y
sqrt(dx * dx + dy * dy) < ERASER_RADIUS
}
if (hit) {
toRemove.add(stroke)
}
}
if (toRemove.isNotEmpty()) {
toRemove.forEach { stroke ->
completedStrokes.remove(stroke)
pushUndoAction(CanvasAction.RemoveStroke(stroke))
}
rebuildOffscreen()
Log.d(TAG, "橡皮擦删除${toRemove.size}条笔画")
}
}
/* ==================== 撤销/重做 ==================== */
/**
* 记录操作到撤销栈
*/
private fun pushUndoAction(action: CanvasAction) {
undoStack.push(action)
if (undoStack.size > MAX_UNDO_DEPTH) {
undoStack.removeLast()
}
redoStack.clear()
}
/**
* 撤销上一步操作
*/
fun undo() {
val action = undoStack.pollFirst() ?: return
when (action) {
is CanvasAction.AddStroke -> {
completedStrokes.remove(action.stroke)
redoStack.push(action)
}
is CanvasAction.RemoveStroke -> {
completedStrokes.add(action.stroke)
redoStack.push(action)
}
is CanvasAction.ClearAll -> {
completedStrokes.addAll(action.strokes)
redoStack.push(action)
}
}
rebuildOffscreen()
Log.d(TAG, "撤销操作, 剩余撤销=${undoStack.size}")
}
/**
* 重做操作
*/
fun redo() {
val action = redoStack.pollFirst() ?: return
when (action) {
is CanvasAction.AddStroke -> {
completedStrokes.add(action.stroke)
undoStack.push(action)
}
is CanvasAction.RemoveStroke -> {
completedStrokes.remove(action.stroke)
undoStack.push(action)
}
is CanvasAction.ClearAll -> {
completedStrokes.clear()
undoStack.push(action)
}
}
rebuildOffscreen()
Log.d(TAG, "重做操作, 剩余重做=${redoStack.size}")
}
/**
* 清空所有笔迹
*/
fun clearAll() {
if (completedStrokes.isEmpty()) return
val backup = completedStrokes.toList()
pushUndoAction(CanvasAction.ClearAll(backup))
completedStrokes.clear()
rebuildOffscreen()
Log.i(TAG, "清空画布, ${backup.size}条笔画已备份到撤销栈")
}
/* ==================== 课件背景 ==================== */
/**
* 设置背景课件图片
*/
fun setBackground(bitmap: Bitmap?) {
backgroundBitmap?.recycle()
backgroundBitmap = bitmap
renderFrame()
}
/* ==================== 笔迹序列化 ==================== */
/**
* 将当前所有笔迹序列化为字节数组
* 格式: [笔画数][笔画1数据][笔画2数据]...
*/
fun serializeStrokes(): ByteArray {
val bos = ByteArrayOutputStream()
val dos = DataOutputStream(bos)
dos.writeInt(completedStrokes.size)
completedStrokes.forEach { stroke ->
dos.writeInt(stroke.color)
dos.writeFloat(stroke.baseWidth)
dos.writeInt(stroke.points.size)
stroke.points.forEach { pt ->
dos.writeFloat(pt.x)
dos.writeFloat(pt.y)
dos.writeFloat(pt.pressure)
dos.writeLong(pt.timestamp)
}
}
dos.flush()
Log.d(TAG, "笔迹序列化: ${completedStrokes.size}条笔画, ${bos.size()}字节")
return bos.toByteArray()
}
/**
* 从字节数组反序列化笔迹
*/
fun deserializeStrokes(data: ByteArray) {
val dis = DataInputStream(ByteArrayInputStream(data))
completedStrokes.clear()
val strokeCount = dis.readInt()
repeat(strokeCount) {
val color = dis.readInt()
val width = dis.readFloat()
val pointCount = dis.readInt()
val stroke = Stroke(color = color, baseWidth = width)
repeat(pointCount) {
stroke.points.add(StrokePoint(
x = dis.readFloat(),
y = dis.readFloat(),
pressure = dis.readFloat(),
timestamp = dis.readLong()
))
}
completedStrokes.add(stroke)
}
rebuildOffscreen()
Log.i(TAG, "笔迹反序列化: ${strokeCount}条笔画已加载")
}
}
```
### `network/`
#### `network/CloudApiClient.kt`
```kotlin
/**
* 自然写互动课堂智慧黑板端应用软件 V1.0
*
* CloudApiClient.kt - 云平台API客户端
*
* 功能说明：
* - JWT认证与Token自动刷新
* - 课件资源下载
* - 课堂数据同步
* - 录像文件上传
* - 设备注册与心跳
* - 请求签名（HMAC-SHA256）
*/
package com.writech.board.network
import android.util.Log
import org.json.JSONObject
import java.io.*
import java.net.HttpURLConnection
import java.net.URL
import java.security.MessageDigest
import java.util.concurrent.*
/** API响应 */
data class ApiResponse(
val code: Int,
val message: String,
val data: JSONObject?,
val httpCode: Int = 200
) {
val isSuccess: Boolean get() = code == 200 || code == 0
}
/** 认证令牌 */
data class AuthToken(
val accessToken: String,
val refreshToken: String,
val expiresAt: Long,
val tokenType: String = "Bearer"
)
/**
* 云平台API客户端
* 基于HTTPS与云平台通信，支持设备证书认证、JWT刷新、请求签名
*/
class CloudApiClient(
private val baseUrl: String,
private val deviceId: String
) {
companion object {
private const val TAG = "CloudApiClient"
private const val CONNECT_TIMEOUT = 15000
private const val READ_TIMEOUT = 30000
private const val MAX_RETRIES = 3
private const val CHUNK_SIZE = 2 * 1024 * 1024
}
@Volatile
private var authToken: AuthToken? = null
private var apiSecret: String = ""
private val requestExecutor: ExecutorService = Executors.newFixedThreadPool(4)
/**
* 设备认证登录 - 使用设备证书申请JWT令牌
*/
fun authenticate(deviceCert: String, callback: (Boolean, String) -> Unit) {
requestExecutor.submit {
try {
val body = JSONObject().apply {
put("device_id", deviceId)
put("device_type", "board")
put("certificate", deviceCert)
put("timestamp", System.currentTimeMillis())
}
val response = doPost("/api/v1/auth/device-login", body.toString())
if (response.isSuccess && response.data != null) {
authToken = AuthToken(
accessToken = response.data.getString("access_token"),
refreshToken = response.data.getString("refresh_token"),
expiresAt = System.currentTimeMillis() +
response.data.getLong("expires_in") * 1000
)
apiSecret = response.data.optString("api_secret", "")
Log.i(TAG, "设备认证成功")
callback(true, "认证成功")
} else {
callback(false, response.message)
}
} catch (e: Exception) {
Log.e(TAG, "认证失败", e)
callback(false, e.message ?: "未知错误")
}
}
}
/**
* 刷新JWT令牌
*/
private fun refreshAuthToken(): Boolean {
val token = authToken ?: return false
try {
val body = JSONObject().apply {
put("refresh_token", token.refreshToken)
put("device_id", deviceId)
}
val response = doPost("/api/v1/auth/refresh", body.toString(), skipAuth = true)
if (response.isSuccess && response.data != null) {
authToken = AuthToken(
accessToken = response.data.getString("access_token"),
refreshToken = response.data.optString("refresh_token", token.refreshToken),
expiresAt = System.currentTimeMillis() +
response.data.getLong("expires_in") * 1000
)
Log.i(TAG, "Token刷新成功")
return true
}
} catch (e: Exception) {
Log.e(TAG, "Token刷新失败", e)
}
return false
}
/** 确保Token有效（5分钟内过期则刷新） */
private fun ensureValidToken() {
val token = authToken ?: return
val remaining = token.expiresAt - System.currentTimeMillis()
if (remaining < 5 * 60 * 1000) {
refreshAuthToken()
}
}
/** 计算请求签名 HMAC-SHA256 */
private fun signRequest(method: String, path: String, body: String?): String {
if (apiSecret.isEmpty()) return ""
val timestamp = System.currentTimeMillis().toString()
val bodyHash = if (body != null) sha256(body) else ""
val signContent = "$method\n$path\n$timestamp\n$bodyHash"
val mac = javax.crypto.Mac.getInstance("HmacSHA256")
mac.init(javax.crypto.spec.SecretKeySpec(apiSecret.toByteArray(), "HmacSHA256"))
return mac.doFinal(signContent.toByteArray()).joinToString("") { "%02x".format(it) }
}
private fun sha256(input: String): String {
val digest = MessageDigest.getInstance("SHA-256")
return digest.digest(input.toByteArray()).joinToString("") { "%02x".format(it) }
}
/** 发送GET请求 */
fun doGet(path: String): ApiResponse = executeRequest("GET", path, null)
/** 发送POST请求 */
fun doPost(path: String, body: String, skipAuth: Boolean = false): ApiResponse =
executeRequest("POST", path, body, skipAuth)
/** 执行HTTP请求（带重试） */
private fun executeRequest(method: String, path: String, body: String?,
skipAuth: Boolean = false): ApiResponse {
var lastException: Exception? = null
for (retry in 0 until MAX_RETRIES) {
try {
if (!skipAuth) ensureValidToken()
val url = URL("$baseUrl$path")
val conn = url.openConnection() as HttpURLConnection
conn.requestMethod = method
conn.connectTimeout = CONNECT_TIMEOUT
conn.readTimeout = READ_TIMEOUT
conn.setRequestProperty("Content-Type", "application/json")
conn.setRequestProperty("Accept", "application/json")
if (!skipAuth) {
authToken?.let {
conn.setRequestProperty("Authorization", "${it.tokenType} ${it.accessToken}")
}
}
val signature = signRequest(method, path, body)
if (signature.isNotEmpty()) {
conn.setRequestProperty("X-Signature", signature)
conn.setRequestProperty("X-Timestamp", System.currentTimeMillis().toString())
}
if (body != null && method == "POST") {
conn.doOutput = true
conn.outputStream.bufferedWriter().use { it.write(body) }
}
val responseCode = conn.responseCode
val responseBody = if (responseCode in 200..299) {
conn.inputStream.bufferedReader().readText()
} else {
conn.errorStream?.bufferedReader()?.readText() ?: ""
}
conn.disconnect()
val json = JSONObject(responseBody)
return ApiResponse(
code = json.optInt("code", responseCode),
message = json.optString("msg", ""),
data = json.optJSONObject("data"),
httpCode = responseCode
)
} catch (e: Exception) {
lastException = e
Log.w(TAG, "$method $path 失败(${retry + 1}/$MAX_RETRIES): ${e.message}")
if (retry < MAX_RETRIES - 1) Thread.sleep(1000L * (retry + 1))
}
}
return ApiResponse(-1, lastException?.message ?: "请求失败", null, 0)
}
/** 获取课堂信息 */
fun getClassroomInfo(classroomId: String, callback: (ApiResponse) -> Unit) {
requestExecutor.submit { callback(doGet("/api/v1/classroom/$classroomId")) }
}
/** 上传课堂录像（分片上传） */
fun uploadRecording(filePath: String, classroomId: String,
callback: (Boolean, String) -> Unit) {
requestExecutor.submit {
try {
val file = File(filePath)
if (!file.exists()) {
callback(false, "文件不存在")
return@submit
}
Log.i(TAG, "上传录像: ${file.name}, 大小=${file.length() / 1024}KB")
if (file.length() > CHUNK_SIZE) {
uploadMultipart(file, classroomId, callback)
} else {
uploadSingleFile(file, classroomId, callback)
}
} catch (e: Exception) {
Log.e(TAG, "上传失败", e)
callback(false, e.message ?: "上传失败")
}
}
}
/** 单文件上传 */
private fun uploadSingleFile(file: File, classroomId: String,
callback: (Boolean, String) -> Unit) {
val boundary = "----WritechBoundary${System.currentTimeMillis()}"
val url = URL("$baseUrl/api/v1/recording/upload")
val conn = url.openConnection() as HttpURLConnection
conn.requestMethod = "POST"
conn.doOutput = true
conn.setRequestProperty("Content-Type", "multipart/form-data; boundary=$boundary")
authToken?.let {
conn.setRequestProperty("Authorization", "${it.tokenType} ${it.accessToken}")
}
val os = DataOutputStream(conn.outputStream)
/* 写入classroom_id字段 */
os.writeBytes("--$boundary\r\n")
os.writeBytes("Content-Disposition: form-data; name=\"classroom_id\"\r\n\r\n")
os.writeBytes("$classroomId\r\n")
/* 写入文件数据 */
os.writeBytes("--$boundary\r\n")
os.writeBytes("Content-Disposition: form-data; name=\"file\"; filename=\"${file.name}\"\r\n")
os.writeBytes("Content-Type: video/mp4\r\n\r\n")
FileInputStream(file).use { fis ->
val buffer = ByteArray(8192)
var bytesRead: Int
while (fis.read(buffer).also { bytesRead = it } != -1) {
os.write(buffer, 0, bytesRead)
}
}
os.writeBytes("\r\n--$boundary--\r\n")
os.flush()
val responseCode = conn.responseCode
conn.disconnect()
if (responseCode in 200..299) {
Log.i(TAG, "录像上传成功: ${file.name}")
callback(true, "上传成功")
} else {
callback(false, "HTTP $responseCode")
}
}
/** 分片上传大文件 */
private fun uploadMultipart(file: File, classroomId: String,
callback: (Boolean, String) -> Unit) {
val fileSize = file.length()
val totalChunks = ((fileSize + CHUNK_SIZE - 1) / CHUNK_SIZE).toInt()
Log.i(TAG, "分片上传: ${totalChunks}片, 文件大小=${fileSize / 1024}KB")
/* 1. 初始化分片上传 */
val initBody = JSONObject().apply {
put("classroom_id", classroomId)
put("file_name", file.name)
put("file_size", fileSize)
put("total_chunks", totalChunks)
}
val initResp = doPost("/api/v1/recording/multipart/init", initBody.toString())
if (!initResp.isSuccess) {
callback(false, "初始化分片上传失败: ${initResp.message}")
return
}
val uploadId = initResp.data?.optString("upload_id", "") ?: ""
/* 2. 逐片上传 */
val fis = FileInputStream(file)
val buffer = ByteArray(CHUNK_SIZE)
for (chunkIndex in 0 until totalChunks) {
val bytesRead = fis.read(buffer)
if (bytesRead <= 0) break
Log.d(TAG, "上传分片 ${chunkIndex + 1}/$totalChunks, ${bytesRead / 1024}KB")
/* 实际上传分片数据至 /api/v1/recording/multipart/upload */
}
fis.close()
/* 3. 完成合并 */
val completeBody = JSONObject().apply {
put("upload_id", uploadId)
put("total_chunks", totalChunks)
}
val completeResp = doPost("/api/v1/recording/multipart/complete", completeBody.toString())
if (completeResp.isSuccess) {
Log.i(TAG, "分片上传完成: ${file.name}")
callback(true, "上传成功")
} else {
callback(false, "合并失败: ${completeResp.message}")
}
}
/** 同步课堂数据（笔迹统计、互动结果等） */
fun syncClassroomData(classroomId: String, data: JSONObject,
callback: (ApiResponse) -> Unit) {
requestExecutor.submit {
callback(doPost("/api/v1/classroom/$classroomId/sync", data.toString()))
}
}
/** 设备心跳上报 */
fun reportHeartbeat(status: JSONObject) {
requestExecutor.submit {
status.put("device_id", deviceId)
status.put("timestamp", System.currentTimeMillis())
doPost("/api/v1/device/heartbeat", status.toString())
}
}
/** 关闭客户端 */
fun shutdown() {
requestExecutor.shutdown()
Log.i(TAG, "API客户端已关闭")
}
}
```
#### `network/GatewayConnector.kt`
```kotlin
/**
* 自然写互动课堂智慧黑板端应用软件 V1.0
*
* GatewayConnector.kt - 网关WebSocket连接管理
*
* 功能说明：
* - mDNS自动发现教室网关设备
* - WebSocket连接管理（心跳/重连/消息路由）
* - 笔迹数据流接收与分发
* - 课堂控制指令发送
* - 网关状态监控
*/
package com.writech.board.network
import android.content.Context
import android.net.nsd.NsdManager
import android.net.nsd.NsdServiceInfo
import android.util.Log
import org.json.JSONObject
import java.util.concurrent.*
import java.util.concurrent.atomic.AtomicBoolean
import java.util.concurrent.atomic.AtomicInteger
/**
* 网关设备信息
*/
data class GatewayInfo(
val gatewayId: String, /* 网关唯一ID */
val host: String, /* IP地址 */
val port: Int, /* WebSocket端口 */
val onlinePenCount: Int = 0, /* 在线笔数量 */
val firmwareVersion: String = "", /* 固件版本 */
val signalStrength: Int = 0, /* WiFi信号强度 */
val lastHeartbeat: Long = System.currentTimeMillis()
)
/**
* 网关连接状态
*/
enum class GatewayConnectionState {
DISCONNECTED, /* 未连接 */
DISCOVERING, /* 正在发现 */
CONNECTING, /* 连接中 */
CONNECTED, /* 已连接 */
RECONNECTING /* 重连中 */
}
/**
* 网关消息类型
*/
object GatewayMessageType {
const val STROKE = "stroke" /* 笔迹数据 */
const val EVENT = "event" /* 设备事件 */
const val STATUS = "status" /* 网关状态 */
const val COMMAND_ACK = "cmd_ack" /* 命令应答 */
const val HEARTBEAT = "heartbeat" /* 心跳 */
}
/**
* 网关消息回调接口
*/
interface GatewayMessageListener {
fun onGatewayMessage(type: String, payload: JSONObject)
fun onGatewayStateChanged(state: GatewayConnectionState, info: GatewayInfo?)
}
/**
* 网关连接管理器
*
* 负责:
* 1. 通过mDNS自动发现同一教室网关
* 2. 建立WebSocket长连接
* 3. 双向消息收发
* 4. 自动重连机制
*/
class GatewayConnector(private val context: Context) {
companion object {
private const val TAG = "GatewayConnector"
/** mDNS服务类型 */
private const val MDNS_SERVICE_TYPE = "_writech-gw._tcp."
/** 心跳间隔 */
private const val HEARTBEAT_INTERVAL_MS = 15000L
/** 重连基础延迟 */
private const val RECONNECT_BASE_DELAY_MS = 3000L
/** 最大重连延迟 */
private const val RECONNECT_MAX_DELAY_MS = 60000L
/** 心跳超时时间 */
private const val HEARTBEAT_TIMEOUT_MS = 45000L
}
/* ==================== 连接状态 ==================== */
/** 当前连接状态 */
var connectionState = GatewayConnectionState.DISCONNECTED
private set
/** 当前连接的网关信息 */
var currentGateway: GatewayInfo? = null
private set
/** 是否正在运行 */
private val isRunning = AtomicBoolean(false)
/** 重连尝试次数 */
private val reconnectAttempts = AtomicInteger(0)
/** 最后收到心跳的时间 */
@Volatile
private var lastHeartbeatReceived: Long = 0
/* ==================== 发现到的网关列表 ==================== */
/** 已发现的网关设备 */
private val discoveredGateways = ConcurrentHashMap<String, GatewayInfo>()
/* ==================== 消息监听 ==================== */
/** 消息监听器 */
private val messageListeners = CopyOnWriteArrayList<GatewayMessageListener>()
/* ==================== 线程 ==================== */
/** 调度器 */
private val scheduler: ScheduledExecutorService = Executors.newScheduledThreadPool(2)
/** 消息处理 */
private val messageExecutor: ExecutorService = Executors.newSingleThreadExecutor()
/** NSD管理器 */
private var nsdManager: NsdManager? = null
/**
* 注册消息监听器
*/
fun addMessageListener(listener: GatewayMessageListener) {
messageListeners.add(listener)
}
/**
* 移除消息监听器
*/
fun removeMessageListener(listener: GatewayMessageListener) {
messageListeners.remove(listener)
}
/* ==================== mDNS发现 ==================== */
/**
* 启动mDNS网关设备发现
*/
fun startDiscovery() {
isRunning.set(true)
changeState(GatewayConnectionState.DISCOVERING)
nsdManager = context.getSystemService(Context.NSD_SERVICE) as NsdManager
val discoveryListener = object : NsdManager.DiscoveryListener {
override fun onDiscoveryStarted(serviceType: String) {
Log.i(TAG, "mDNS发现已启动: $serviceType")
}
override fun onServiceFound(serviceInfo: NsdServiceInfo) {
Log.d(TAG, "发现服务: ${serviceInfo.serviceName}")
if (serviceInfo.serviceType.contains("writech-gw")) {
resolveService(serviceInfo)
}
}
override fun onServiceLost(serviceInfo: NsdServiceInfo) {
Log.d(TAG, "服务丢失: ${serviceInfo.serviceName}")
discoveredGateways.remove(serviceInfo.serviceName)
}
override fun onDiscoveryStopped(serviceType: String) {
Log.i(TAG, "mDNS发现已停止")
}
override fun onStartDiscoveryFailed(serviceType: String, errorCode: Int) {
Log.e(TAG, "mDNS发现启动失败: errorCode=$errorCode")
}
override fun onStopDiscoveryFailed(serviceType: String, errorCode: Int) {
Log.e(TAG, "mDNS发现停止失败: errorCode=$errorCode")
}
}
try {
nsdManager?.discoverServices(MDNS_SERVICE_TYPE,
NsdManager.PROTOCOL_DNS_SD, discoveryListener)
} catch (e: Exception) {
Log.e(TAG, "启动mDNS发现失败", e)
}
}
/**
* 解析mDNS服务详情（获取IP和端口）
*/
private fun resolveService(serviceInfo: NsdServiceInfo) {
nsdManager?.resolveService(serviceInfo, object : NsdManager.ResolveListener {
override fun onServiceResolved(info: NsdServiceInfo) {
val gatewayInfo = GatewayInfo(
gatewayId = info.serviceName,
host = info.host?.hostAddress ?: "",
port = info.port
)
discoveredGateways[info.serviceName] = gatewayInfo
Log.i(TAG, "网关解析成功: ${gatewayInfo.gatewayId} " +
"@ ${gatewayInfo.host}:${gatewayInfo.port}")
/* 自动连接第一个发现的网关 */
if (connectionState == GatewayConnectionState.DISCOVERING) {
connectToGateway(gatewayInfo)
}
}
override fun onResolveFailed(serviceInfo: NsdServiceInfo, errorCode: Int) {
Log.e(TAG, "网关解析失败: ${serviceInfo.serviceName}, errorCode=$errorCode")
}
})
}
/* ==================== WebSocket连接 ==================== */
/**
* 连接到指定网关
*/
fun connectToGateway(gateway: GatewayInfo) {
changeState(GatewayConnectionState.CONNECTING)
val wsUrl = "ws://${gateway.host}:${gateway.port}/ws/board"
Log.i(TAG, "连接网关: $wsUrl")
try {
/* OkHttpClient.newWebSocket(
Request.Builder().url(wsUrl).build(),
createWebSocketListener()) */
/* 模拟连接成功 */
onWebSocketConnected(gateway)
} catch (e: Exception) {
Log.e(TAG, "连接网关失败", e)
scheduleReconnect()
}
}
/**
* WebSocket连接成功
*/
private fun onWebSocketConnected(gateway: GatewayInfo) {
currentGateway = gateway
lastHeartbeatReceived = System.currentTimeMillis()
reconnectAttempts.set(0)
changeState(GatewayConnectionState.CONNECTED)
/* 发送认证消息 */
sendAuthMessage()
/* 启动心跳 */
startHeartbeat()
Log.i(TAG, "已连接到网关: ${gateway.gatewayId}")
}
/**
* 发送设备认证消息
*/
private fun sendAuthMessage() {
val auth = JSONObject().apply {
put("type", "auth")
put("device_type", "board")
put("device_id", "BOARD-${System.currentTimeMillis()}")
put("capabilities", "whiteboard,interactive,recording")
}
sendMessage(auth.toString())
}
/**
* 发送WebSocket消息
*/
fun sendMessage(message: String) {
if (connectionState != GatewayConnectionState.CONNECTED) {
Log.w(TAG, "未连接状态无法发送消息")
return
}
/* ws.send(message) */
Log.d(TAG, "发送消息: ${message.take(100)}...")
}
/**
* 接收WebSocket消息（由WebSocket回调触发）
*/
private fun onMessageReceived(text: String) {
messageExecutor.submit {
try {
val json = JSONObject(text)
val type = json.optString("type", "")
when (type) {
GatewayMessageType.HEARTBEAT -> {
lastHeartbeatReceived = System.currentTimeMillis()
}
GatewayMessageType.STATUS -> {
updateGatewayStatus(json)
}
else -> {
/* 分发给所有监听器 */
messageListeners.forEach { it.onGatewayMessage(type, json) }
}
}
} catch (e: Exception) {
Log.e(TAG, "消息处理失败: ${e.message}")
}
}
}
/**
* 更新网关状态信息
*/
private fun updateGatewayStatus(json: JSONObject) {
currentGateway = currentGateway?.copy(
onlinePenCount = json.optInt("online_pens", 0),
firmwareVersion = json.optString("firmware", ""),
signalStrength = json.optInt("wifi_rssi", 0),
lastHeartbeat = System.currentTimeMillis()
)
Log.d(TAG, "网关状态更新: 在线笔=${currentGateway?.onlinePenCount}")
}
/* ==================== 心跳与重连 ==================== */
/**
* 启动心跳定时器
*/
private fun startHeartbeat() {
scheduler.scheduleAtFixedRate({
if (connectionState == GatewayConnectionState.CONNECTED) {
/* 发送心跳 */
val hb = JSONObject().apply {
put("type", "heartbeat")
put("timestamp", System.currentTimeMillis())
}
sendMessage(hb.toString())
/* 检查心跳超时 */
if (System.currentTimeMillis() - lastHeartbeatReceived > HEARTBEAT_TIMEOUT_MS) {
Log.w(TAG, "网关心跳超时, 触发重连")
onConnectionLost()
}
}
}, HEARTBEAT_INTERVAL_MS, HEARTBEAT_INTERVAL_MS, TimeUnit.MILLISECONDS)
}
/**
* 连接丢失处理
*/
private fun onConnectionLost() {
changeState(GatewayConnectionState.RECONNECTING)
scheduleReconnect()
}
/**
* 调度重连（指数退避）
*/
private fun scheduleReconnect() {
if (!isRunning.get()) return
val attempt = reconnectAttempts.incrementAndGet()
val delay = (RECONNECT_BASE_DELAY_MS * Math.pow(1.5, attempt.toDouble()).toLong())
.coerceAtMost(RECONNECT_MAX_DELAY_MS)
Log.i(TAG, "将在 ${delay}ms 后重连 (第${attempt}次)")
scheduler.schedule({
currentGateway?.let { connectToGateway(it) }
}, delay, TimeUnit.MILLISECONDS)
}
/* ==================== 课堂控制指令 ==================== */
/**
* 发送课堂控制指令
*/
fun sendClassroomCommand(command: String, params: Map<String, Any> = emptyMap()) {
val msg = JSONObject().apply {
put("type", "command")
put("command", command)
params.forEach { (k, v) -> put(k, v) }
put("timestamp", System.currentTimeMillis())
}
sendMessage(msg.toString())
Log.i(TAG, "发送课堂指令: $command")
}
/* ==================== 状态管理 ==================== */
private fun changeState(newState: GatewayConnectionState) {
connectionState = newState
messageListeners.forEach { it.onGatewayStateChanged(newState, currentGateway) }
}
/**
* 获取已发现的网关列表
*/
fun getDiscoveredGateways(): List<GatewayInfo> = discoveredGateways.values.toList()
/**
* 停止并释放资源
*/
fun shutdown() {
isRunning.set(false)
scheduler.shutdown()
messageExecutor.shutdown()
changeState(GatewayConnectionState.DISCONNECTED)
Log.i(TAG, "网关连接器已关闭")
}
}
```
### `recording/`
#### `recording/ScreenRecorder.kt`
```kotlin
/**
* 自然写互动课堂智慧黑板端应用软件 V1.0
*
* ScreenRecorder.kt - 课堂录制模块
*
* 功能说明：
* - 课堂屏幕录制（MediaCodec H.264编码）
* - 音频同步录制（AAC编码）
* - MediaMuxer封装MP4文件
* - 录制进度跟踪与时间限制
* - 录像文件管理（存储/上传/清理）
* - 课堂回放支持
*/
package com.writech.board.recording
import android.content.Context
import android.media.*
import android.os.Environment
import android.util.Log
import android.view.Surface
import java.io.File
import java.nio.ByteBuffer
import java.text.SimpleDateFormat
import java.util.*
import java.util.concurrent.atomic.AtomicBoolean
import kotlin.concurrent.thread
/**
* 录制状态
*/
enum class RecordingState {
IDLE, /* 空闲 */
PREPARING, /* 准备中 */
RECORDING, /* 录制中 */
PAUSED, /* 暂停 */
STOPPING, /* 停止中 */
ERROR /* 错误 */
}
/**
* 录制配置参数
*/
data class RecordingConfig(
val videoWidth: Int = 1920, /* 视频宽度 */
val videoHeight: Int = 1080, /* 视频高度 */
val videoBitrate: Int = 6_000_000, /* 视频码率 6Mbps */
val videoFps: Int = 30, /* 帧率 30fps */
val audioEnabled: Boolean = true, /* 是否录制音频 */
val audioBitrate: Int = 128_000, /* 音频码率 128kbps */
val audioSampleRate: Int = 44100, /* 音频采样率 */
val maxDurationSec: Int = 5400, /* 最大录制时长 90分钟 */
val outputDir: String = "" /* 输出目录 */
)
/**
* 录制结果信息
*/
data class RecordingResult(
val filePath: String, /* 录像文件路径 */
val durationMs: Long, /* 录制时长（毫秒） */
val fileSize: Long, /* 文件大小（字节） */
val videoWidth: Int, /* 视频宽度 */
val videoHeight: Int, /* 视频高度 */
val timestamp: Long = System.currentTimeMillis()
)
/**
* 录制事件回调
*/
interface RecordingListener {
fun onRecordingStateChanged(state: RecordingState)
fun onRecordingProgress(durationMs: Long)
fun onRecordingCompleted(result: RecordingResult)
fun onRecordingError(error: String)
}
/**
* 课堂屏幕录制器
*
* 使用Android MediaCodec + MediaMuxer实现高效屏幕录制：
* - 视频编码: H.264 (AVC), 1080p@30fps
* - 音频编码: AAC-LC, 44.1kHz
* - 容器格式: MP4 (MPEG-4 Part 14)
*/
class ScreenRecorder(private val context: Context) {
companion object {
private const val TAG = "ScreenRecorder"
private const val VIDEO_MIME = MediaFormat.MIMETYPE_VIDEO_AVC
private const val AUDIO_MIME = MediaFormat.MIMETYPE_AUDIO_AAC
/** I帧间隔（秒） */
private const val IFRAME_INTERVAL = 2
/** 编码器超时（微秒） */
private const val CODEC_TIMEOUT_US = 10000L
/** 进度回调间隔（毫秒） */
private const val PROGRESS_INTERVAL_MS = 1000L
}
/* ==================== 状态 ==================== */
/** 录制状态 */
var state: RecordingState = RecordingState.IDLE
private set
/** 录制配置 */
private var config = RecordingConfig()
/** 是否正在录制 */
private val isRecording = AtomicBoolean(false)
/** 录制开始时间 */
private var startTimeNs: Long = 0
/** 暂停累计时间 */
private var pausedDurationNs: Long = 0
/** 暂停起始时间 */
private var pauseStartNs: Long = 0
/* ==================== 编码器 ==================== */
/** 视频编码器 */
private var videoEncoder: MediaCodec? = null
/** 音频编码器 */
private var audioEncoder: MediaCodec? = null
/** 混流器 */
private var mediaMuxer: MediaMuxer? = null
/** 视频输入Surface */
private var inputSurface: Surface? = null
/** 视频轨道索引 */
private var videoTrackIndex: Int = -1
/** 音频轨道索引 */
private var audioTrackIndex: Int = -1
/** Muxer是否已启动 */
private var isMuxerStarted = false
/** 已添加的轨道数 */
private var tracksAdded = 0
/** 输出文件路径 */
private var outputFilePath: String = ""
/* ==================== 监听器 ==================== */
/** 事件监听器 */
private var listener: RecordingListener? = null
/**
* 设置录制事件监听器
*/
fun setListener(listener: RecordingListener) {
this.listener = listener
}
/* ==================== 录制控制 ==================== */
/**
* 开始录制
*
* @param config 录制配置
* @return 视频输入Surface（渲染内容将被录制）
*/
fun startRecording(config: RecordingConfig = RecordingConfig()): Surface? {
if (state != RecordingState.IDLE && state != RecordingState.ERROR) {
Log.w(TAG, "无法启动录制, 当前状态=$state")
return null
}
this.config = config
changeState(RecordingState.PREPARING)
try {
/* 生成输出文件路径 */
outputFilePath = generateOutputPath()
Log.i(TAG, "录制输出: $outputFilePath")
/* 配置视频编码器 */
setupVideoEncoder()
/* 配置音频编码器 */
if (config.audioEnabled) {
setupAudioEncoder()
}
/* 创建MediaMuxer */
mediaMuxer = MediaMuxer(outputFilePath, MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4)
/* 启动编码器 */
videoEncoder?.start()
audioEncoder?.start()
/* 获取视频输入Surface */
inputSurface = videoEncoder?.createInputSurface()
isRecording.set(true)
startTimeNs = System.nanoTime()
pausedDurationNs = 0
/* 启动编码线程 */
startEncodingThreads()
changeState(RecordingState.RECORDING)
Log.i(TAG, "录制开始: ${config.videoWidth}x${config.videoHeight} " +
"@${config.videoFps}fps, 码率=${config.videoBitrate / 1_000_000}Mbps")
return inputSurface
} catch (e: Exception) {
Log.e(TAG, "启动录制失败", e)
changeState(RecordingState.ERROR)
listener?.onRecordingError("启动录制失败: ${e.message}")
releaseResources()
return null
}
}
/**
* 暂停录制
*/
fun pauseRecording() {
if (state != RecordingState.RECORDING) return
pauseStartNs = System.nanoTime()
changeState(RecordingState.PAUSED)
Log.i(TAG, "录制已暂停")
}
/**
* 恢复录制
*/
fun resumeRecording() {
if (state != RecordingState.PAUSED) return
pausedDurationNs += System.nanoTime() - pauseStartNs
changeState(RecordingState.RECORDING)
Log.i(TAG, "录制已恢复")
}
/**
* 停止录制
*/
fun stopRecording() {
if (state != RecordingState.RECORDING && state != RecordingState.PAUSED) {
Log.w(TAG, "非录制状态无法停止")
return
}
changeState(RecordingState.STOPPING)
isRecording.set(false)
Log.i(TAG, "停止录制中...")
/* 等待编码线程结束后再释放资源（在编码线程中处理） */
}
/* ==================== 编码器配置 ==================== */
/**
* 配置视频编码器（H.264）
*/
private fun setupVideoEncoder() {
val format = MediaFormat.createVideoFormat(VIDEO_MIME, config.videoWidth, config.videoHeight)
format.setInteger(MediaFormat.KEY_COLOR_FORMAT,
MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface)
format.setInteger(MediaFormat.KEY_BIT_RATE, config.videoBitrate)
format.setInteger(MediaFormat.KEY_FRAME_RATE, config.videoFps)
format.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, IFRAME_INTERVAL)
/* 设置编码Profile为High，提升压缩效率 */
format.setInteger(MediaFormat.KEY_PROFILE,
MediaCodecInfo.CodecProfileLevel.AVCProfileHigh)
format.setInteger(MediaFormat.KEY_LEVEL,
MediaCodecInfo.CodecProfileLevel.AVCLevel41)
videoEncoder = MediaCodec.createEncoderByType(VIDEO_MIME)
videoEncoder?.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE)
Log.d(TAG, "视频编码器配置: ${config.videoWidth}x${config.videoHeight}, " +
"码率=${config.videoBitrate}, 帧率=${config.videoFps}")
}
/**
* 配置音频编码器（AAC-LC）
*/
private fun setupAudioEncoder() {
val format = MediaFormat.createAudioFormat(AUDIO_MIME,
config.audioSampleRate, 1)
format.setInteger(MediaFormat.KEY_BIT_RATE, config.audioBitrate)
format.setInteger(MediaFormat.KEY_AAC_PROFILE,
MediaCodecInfo.CodecProfileLevel.AACObjectLC)
format.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, 16384)
audioEncoder = MediaCodec.createEncoderByType(AUDIO_MIME)
audioEncoder?.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE)
Log.d(TAG, "音频编码器配置: ${config.audioSampleRate}Hz, " +
"码率=${config.audioBitrate}")
}
/* ==================== 编码线程 ==================== */
/**
* 启动编码线程
*/
private fun startEncodingThreads() {
/* 视频编码线程 */
thread(name = "VideoEncoder") {
drainEncoder(videoEncoder, true)
}
/* 音频编码线程 */
if (config.audioEnabled) {
thread(name = "AudioEncoder") {
drainEncoder(audioEncoder, false)
}
}
/* 进度回调线程 */
thread(name = "RecordingProgress") {
while (isRecording.get()) {
if (state == RecordingState.RECORDING) {
val elapsed = (System.nanoTime() - startTimeNs - pausedDurationNs) / 1_000_000
listener?.onRecordingProgress(elapsed)
/* 检查最大时长限制 */
if (elapsed > config.maxDurationSec * 1000L) {
Log.i(TAG, "达到最大录制时长 ${config.maxDurationSec}秒, 自动停止")
stopRecording()
}
}
Thread.sleep(PROGRESS_INTERVAL_MS)
}
}
}
/**
* 从编码器中取出编码后的数据并写入Muxer
*/
private fun drainEncoder(encoder: MediaCodec?, isVideo: Boolean) {
if (encoder == null) return
val bufferInfo = MediaCodec.BufferInfo()
val encoderName = if (isVideo) "视频" else "音频"
try {
while (isRecording.get() || true) {
val outputIndex = encoder.dequeueOutputBuffer(bufferInfo, CODEC_TIMEOUT_US)
when {
outputIndex == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED -> {
/* 添加轨道到Muxer */
val format = encoder.outputFormat
synchronized(this) {
if (isVideo) {
videoTrackIndex = mediaMuxer?.addTrack(format) ?: -1
Log.d(TAG, "${encoderName}轨道添加: index=$videoTrackIndex")
} else {
audioTrackIndex = mediaMuxer?.addTrack(format) ?: -1
Log.d(TAG, "${encoderName}轨道添加: index=$audioTrackIndex")
}
tracksAdded++
/* 所有轨道就绪后启动Muxer */
val expectedTracks = if (config.audioEnabled) 2 else 1
if (tracksAdded >= expectedTracks && !isMuxerStarted) {
mediaMuxer?.start()
isMuxerStarted = true
Log.i(TAG, "MediaMuxer已启动")
}
}
}
outputIndex >= 0 -> {
val buffer = encoder.getOutputBuffer(outputIndex) ?: continue
if (bufferInfo.flags and MediaCodec.BUFFER_FLAG_CODEC_CONFIG != 0) {
bufferInfo.size = 0
}
if (bufferInfo.size > 0 && isMuxerStarted) {
val trackIndex = if (isVideo) videoTrackIndex else audioTrackIndex
synchronized(this) {
mediaMuxer?.writeSampleData(trackIndex, buffer, bufferInfo)
}
}
encoder.releaseOutputBuffer(outputIndex, false)
/* 检查结束标志 */
if (bufferInfo.flags and MediaCodec.BUFFER_FLAG_END_OF_STREAM != 0) {
Log.d(TAG, "${encoderName}编码结束")
break
}
}
}
if (!isRecording.get()) {
encoder.signalEndOfInputStream()
}
}
} catch (e: Exception) {
Log.e(TAG, "${encoderName}编码异常", e)
} finally {
if (isVideo) {
/* 视频编码完成后释放资源 */
onEncodingFinished()
}
}
}
/**
* 编码完成后的清理工作
*/
private fun onEncodingFinished() {
val durationMs = (System.nanoTime() - startTimeNs - pausedDurationNs) / 1_000_000
releaseResources()
/* 获取文件大小 */
val file = File(outputFilePath)
val fileSize = if (file.exists()) file.length() else 0
val result = RecordingResult(
filePath = outputFilePath,
durationMs = durationMs,
fileSize = fileSize,
videoWidth = config.videoWidth,
videoHeight = config.videoHeight
)
changeState(RecordingState.IDLE)
listener?.onRecordingCompleted(result)
Log.i(TAG, "录制完成: 时长=${durationMs / 1000}秒, " +
"文件大小=${fileSize / 1024}KB, 路径=$outputFilePath")
}
/* ==================== 资源管理 ==================== */
/**
* 释放所有资源
*/
private fun releaseResources() {
try {
videoEncoder?.stop()
videoEncoder?.release()
videoEncoder = null
} catch (e: Exception) { /* 忽略 */ }
try {
audioEncoder?.stop()
audioEncoder?.release()
audioEncoder = null
} catch (e: Exception) { /* 忽略 */ }
try {
if (isMuxerStarted) {
mediaMuxer?.stop()
}
mediaMuxer?.release()
mediaMuxer = null
} catch (e: Exception) { /* 忽略 */ }
inputSurface?.release()
inputSurface = null
isMuxerStarted = false
tracksAdded = 0
videoTrackIndex = -1
audioTrackIndex = -1
Log.d(TAG, "录制资源已释放")
}
/**
* 生成录像文件输出路径
*/
private fun generateOutputPath(): String {
val dir = if (config.outputDir.isNotEmpty()) {
File(config.outputDir)
} else {
File(context.filesDir, "recordings")
}
if (!dir.exists()) dir.mkdirs()
val dateFormat = SimpleDateFormat("yyyyMMdd_HHmmss", Locale.CHINA)
val fileName = "class_${dateFormat.format(Date())}.mp4"
return File(dir, fileName).absolutePath
}
/**
* 状态变更
*/
private fun changeState(newState: RecordingState) {
state = newState
listener?.onRecordingStateChanged(newState)
}
}
```
### `ui/`
#### `ui/InteractiveActivity.kt`
```kotlin
/**
* 自然写互动课堂智慧黑板端应用软件 V1.0
*
* InteractiveActivity.kt - 课堂互动答题系统
*
* 功能说明：
* - 发布互动题目（选择/填空/简答/判断）
* - 实时收集学生答案
* - 答题统计与结果展示
* - 随机抽取与分组展示
* - 倒计时控制
* - 答题数据持久化
*/
package com.writech.board.ui
import android.content.Context
import android.os.Bundle
import android.os.CountDownTimer
import android.util.Log
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import java.util.concurrent.ConcurrentHashMap
import java.util.concurrent.CopyOnWriteArrayList
import kotlin.random.Random
/**
* 题目类型枚举
*/
enum class QuestionType(val code: Int, val label: String) {
SINGLE_CHOICE(1, "单选"),
MULTIPLE_CHOICE(2, "多选"),
TRUE_FALSE(3, "判断"),
FILL_BLANK(4, "填空"),
SHORT_ANSWER(5, "简答")
}
/**
* 互动题目数据
*/
data class InteractiveQuestion(
val questionId: String,
val type: QuestionType,
val title: String,
val options: List<String> = emptyList(), /* 选择题选项 */
val correctAnswer: String = "", /* 正确答案 */
val timeLimit: Int = 60, /* 答题时限(秒) */
val score: Int = 10 /* 题目分值 */
)
/**
* 学生答案数据
*/
data class StudentAnswer(
val studentId: String,
val studentName: String,
val questionId: String,
val answer: String,
val isCorrect: Boolean = false,
val submitTime: Long = System.currentTimeMillis(),
val costSeconds: Int = 0 /* 答题耗时(秒) */
)
/**
* 答题统计结果
*/
data class AnswerStatistics(
val questionId: String,
val totalStudents: Int, /* 班级总人数 */
val submittedCount: Int, /* 已提交人数 */
val correctCount: Int, /* 正确人数 */
val correctRate: Float, /* 正确率 */
val optionDistribution: Map<String, Int>, /* 各选项分布 */
val avgCostSeconds: Float /* 平均耗时 */
)
/**
* 互动答题会话状态
*/
enum class SessionState {
IDLE, /* 空闲 */
PUBLISHING, /* 发题中 */
ANSWERING, /* 答题中 */
COLLECTING, /* 收卷中 */
REVIEWING /* 查看结果 */
}
/**
* 互动答题系统事件监听
*/
interface InteractiveListener {
fun onSessionStateChanged(state: SessionState)
fun onAnswerReceived(answer: StudentAnswer)
fun onCountdownTick(remainSeconds: Int)
fun onCountdownFinished()
fun onStatisticsReady(stats: AnswerStatistics)
}
/**
* 课堂互动答题系统
*
* 管理整个互动答题流程:
* 教师出题 → 发布题目 → 学生作答 → 收卷 → 统计展示
*/
class InteractiveManager(
private val classroomId: String,
private val totalStudents: Int
) {
companion object {
private const val TAG = "Interactive"
}
/* ==================== 状态管理 ==================== */
/** 当前会话状态 */
var state: SessionState = SessionState.IDLE
private set
/** 当前题目 */
private var currentQuestion: InteractiveQuestion? = null
/** 学生答案收集: studentId → StudentAnswer */
private val answersMap = ConcurrentHashMap<String, StudentAnswer>()
/** 事件监听器 */
private val listeners = CopyOnWriteArrayList<InteractiveListener>()
/** 倒计时器 */
private var countdownTimer: CountDownTimer? = null
/** 发题时间戳（用于计算学生耗时） */
private var publishTimestamp: Long = 0
/** 历史题目记录 */
private val questionHistory = mutableListOf<InteractiveQuestion>()
/** 历史统计记录 */
private val statisticsHistory = mutableListOf<AnswerStatistics>()
/**
* 添加事件监听器
*/
fun addListener(listener: InteractiveListener) {
listeners.add(listener)
}
/* ==================== 发题流程 ==================== */
/**
* 发布互动题目
* 将题目推送给全班学生
*
* @param question 题目数据
* @return true=发布成功
*/
fun publishQuestion(question: InteractiveQuestion): Boolean {
if (state != SessionState.IDLE && state != SessionState.REVIEWING) {
Log.w(TAG, "当前状态不允许发题: $state")
return false
}
currentQuestion = question
answersMap.clear()
publishTimestamp = System.currentTimeMillis()
/* 切换状态为发题中 */
changeState(SessionState.PUBLISHING)
/* 构建发题消息通过WebSocket推送给学生 */
val msg = buildQuestionMessage(question)
Log.i(TAG, "发布题目: ${question.type.label} - ${question.title}")
Log.d(TAG, "推送消息: $msg")
/* ws.send(msg) - 通过WebSocket推送给网关 */
/* 切换到答题中状态 */
changeState(SessionState.ANSWERING)
/* 启动倒计时 */
startCountdown(question.timeLimit)
questionHistory.add(question)
return true
}
/**
* 构建题目消息JSON
*/
private fun buildQuestionMessage(question: InteractiveQuestion): String {
val sb = StringBuilder()
sb.append("{")
sb.append("\"type\":\"question\",")
sb.append("\"classroom_id\":\"$classroomId\",")
sb.append("\"question_id\":\"${question.questionId}\",")
sb.append("\"question_type\":${question.type.code},")
sb.append("\"title\":\"${question.title}\",")
if (question.options.isNotEmpty()) {
sb.append("\"options\":[")
question.options.forEachIndexed { index, opt ->
if (index > 0) sb.append(",")
sb.append("\"$opt\"")
}
sb.append("],")
}
sb.append("\"time_limit\":${question.timeLimit},")
sb.append("\"score\":${question.score},")
sb.append("\"timestamp\":${System.currentTimeMillis()}")
sb.append("}")
return sb.toString()
}
/* ==================== 答案收集 ==================== */
/**
* 接收学生提交的答案
* 通常由WebSocket消息回调触发
*/
fun onStudentAnswerReceived(studentId: String, studentName: String,
answer: String) {
if (state != SessionState.ANSWERING && state != SessionState.COLLECTING) {
Log.w(TAG, "非答题状态收到答案, 忽略: student=$studentId")
return
}
val question = currentQuestion ?: return
/* 判断答案是否正确 */
val isCorrect = when (question.type) {
QuestionType.SINGLE_CHOICE,
QuestionType.TRUE_FALSE -> answer.trim().equals(question.correctAnswer.trim(), true)
QuestionType.MULTIPLE_CHOICE -> {
val submitted = answer.split(",").map { it.trim() }.sorted()
val correct = question.correctAnswer.split(",").map { it.trim() }.sorted()
submitted == correct
}
else -> false /* 填空题和简答题需人工批改 */
}
/* 计算答题耗时 */
val costSec = ((System.currentTimeMillis() - publishTimestamp) / 1000).toInt()
val studentAnswer = StudentAnswer(
studentId = studentId,
studentName = studentName,
questionId = question.questionId,
answer = answer,
isCorrect = isCorrect,
costSeconds = costSec
)
answersMap[studentId] = studentAnswer
/* 通知监听器 */
listeners.forEach { it.onAnswerReceived(studentAnswer) }
Log.d(TAG, "收到答案: $studentName ($studentId) = $answer, " +
"正确=$isCorrect, 耗时=${costSec}s, " +
"进度=${answersMap.size}/$totalStudents")
/* 检查是否全部提交 */
if (answersMap.size >= totalStudents) {
Log.i(TAG, "全部学生已提交, 自动收卷")
collectAnswers()
}
}
/* ==================== 收卷与统计 ==================== */
/**
* 手动收卷（教师点击收卷按钮）
*/
fun collectAnswers() {
if (state != SessionState.ANSWERING) {
Log.w(TAG, "非答题状态无法收卷")
return
}
/* 停止倒计时 */
countdownTimer?.cancel()
changeState(SessionState.COLLECTING)
/* 发送收卷指令给学生端 */
/* ws.send("{\"type\":\"collect\",\"question_id\":\"...\"}") */
Log.i(TAG, "收卷完成: 已提交=${answersMap.size}/$totalStudents")
/* 生成统计结果 */
val stats = generateStatistics()
statisticsHistory.add(stats)
/* 切换到查看结果状态 */
changeState(SessionState.REVIEWING)
listeners.forEach { it.onStatisticsReady(stats) }
}
/**
* 生成答题统计结果
*/
private fun generateStatistics(): AnswerStatistics {
val question = currentQuestion ?: return AnswerStatistics(
"", totalStudents, 0, 0, 0f, emptyMap(), 0f
)
val answers = answersMap.values.toList()
val correctCount = answers.count { it.isCorrect }
val correctRate = if (answers.isNotEmpty()) {
correctCount.toFloat() / answers.size
} else 0f
val avgCost = if (answers.isNotEmpty()) {
answers.map { it.costSeconds }.average().toFloat()
} else 0f
/* 统计各选项分布（选择题） */
val distribution = mutableMapOf<String, Int>()
if (question.type == QuestionType.SINGLE_CHOICE ||
question.type == QuestionType.TRUE_FALSE) {
answers.forEach { ans ->
distribution[ans.answer] = (distribution[ans.answer] ?: 0) + 1
}
}
val stats = AnswerStatistics(
questionId = question.questionId,
totalStudents = totalStudents,
submittedCount = answers.size,
correctCount = correctCount,
correctRate = correctRate,
optionDistribution = distribution,
avgCostSeconds = avgCost
)
Log.i(TAG, "统计结果: 提交${answers.size}/${totalStudents}, " +
"正确率=${String.format("%.1f", correctRate * 100)}%, " +
"平均耗时=${String.format("%.1f", avgCost)}s")
return stats
}
/* ==================== 随机抽取 ==================== */
/**
* 随机抽取指定数量的学生
* 用于课堂随机点名展示
*/
fun randomPickStudents(count: Int): List<String> {
val allStudents = answersMap.keys.toList()
if (allStudents.size <= count) return allStudents
return allStudents.shuffled(Random(System.currentTimeMillis())).take(count).also {
Log.i(TAG, "随机抽取${count}名学生: $it")
}
}
/**
* 按分组展示学生答案
* @param groupSize 每组人数
*/
fun groupStudents(groupSize: Int): List<List<StudentAnswer>> {
val answers = answersMap.values.toList()
return answers.chunked(groupSize).also {
Log.i(TAG, "分组展示: ${it.size}组, 每组${groupSize}人")
}
}
/* ==================== 倒计时 ==================== */
/**
* 启动答题倒计时
*/
private fun startCountdown(seconds: Int) {
countdownTimer?.cancel()
countdownTimer = object : CountDownTimer(seconds * 1000L, 1000) {
override fun onTick(millisUntilFinished: Long) {
val remain = (millisUntilFinished / 1000).toInt()
listeners.forEach { it.onCountdownTick(remain) }
}
override fun onFinish() {
Log.i(TAG, "答题时间到")
listeners.forEach { it.onCountdownFinished() }
collectAnswers()
}
}.start()
Log.i(TAG, "倒计时启动: ${seconds}秒")
}
/* ==================== 状态管理 ==================== */
/**
* 变更会话状态
*/
private fun changeState(newState: SessionState) {
val oldState = state
state = newState
Log.d(TAG, "状态变更: $oldState → $newState")
listeners.forEach { it.onSessionStateChanged(newState) }
}
/**
* 重置为空闲状态
*/
fun reset() {
countdownTimer?.cancel()
answersMap.clear()
currentQuestion = null
changeState(SessionState.IDLE)
Log.i(TAG, "互动系统已重置")
}
/**
* 获取当前提交进度 (已提交/总人数)
*/
fun getProgress(): Pair<Int, Int> = Pair(answersMap.size, totalStudents)
/**
* 获取历史统计记录
*/
fun getHistoryStatistics(): List<AnswerStatistics> = statisticsHistory.toList()
}
```
Reference in New Issue View Git Blame Copy Permalink