16 Commits
Author SHA1 Message Date
2509_92447106 086303f9b7 修复导出 2026-11-08 09:30:02 +08:00
2509_92447106 68513876bc chore: remove dist/ from repo and ignore it 2026-11-08 09:17:54 +08:00
2509_92447106 35d7b1f30c 修复 2026-11-08 09:15:46 +08:00
2509_92447106 1b18c3d170 个问题 2026-11-08 09:15:13 +08:00
2509_92447106 e12922ad92 修复更新 2026-11-08 09:07:16 +08:00
2509_92447106 cf6f839ada 添加模型“五带“ 2026-11-08 08:59:54 +08:00
2509_92447106 f8fc0f6018 修复UI渲染 2026-11-07 20:37:22 +08:00
2509_92447106 e4ea4f054e 修复 2026-11-07 20:18:34 +08:00
2509_92447106 639ff1ba57 修复 2026-11-07 20:01:58 +08:00
2509_92447106 d81ab2acaa 修复 2026-11-07 19:31:02 +08:00
2509_92447106 ab39c5103d 修复 2026-11-07 18:55:36 +08:00
2509_92447106 4c9b1f8cb7 修复:更新 2026-11-07 18:54:04 +08:00
2509_92447106 6e23391339 修改 2026-11-07 18:46:11 +08:00
2509_92447106 5760fb77b0 feat:修复部分问题 2026-11-07 17:23:41 +08:00
2509_92447106 153ea88f4f 修改 2026-11-07 16:09:06 +08:00
2509_92447106 60113ab76e 上传 2026-11-07 16:05:56 +08:00
315 changed files with 2924 additions and 39738 deletions

No files matched your search

-393
View File
@@ -1,393 +0,0 @@
# GC-UI alpha 构建(Gitea Actions)
#
# 触发:**仅手动**。定时任务已取消(不再每天自动构建),需要时在 Actions 页面点
# Run workflow,或从命令行调
# POST /api/v1/repos/{owner}/{repo}/actions/workflows/{file}/dispatches。
# 产物:Windows 与 macOS 的 Flutter 前端,发布为一个「预览版(prerelease)」Release —— 不占用 latest。
#
# 为什么是 .gitea/workflows/:本仓库是自建 Gitea,不是 GitHub。Gitea Actions 语法与
# GitHub Actions 基本一致,但工作流目录是 .gitea/workflows/,API 前缀是 /api/v1,
# runner 标签必须与 act_runner 上注册的 label 一致(见 GC-UI/CI.md)。
#
# 为什么 alpha 不会变成 latest:Gitea 的 /releases/latest 按定义只返回「最近一个既非草稿
# 也非 prerelease」的发布,所以 prerelease=true 的版本永远不会被当成 latest。
# publish 任务最后还会主动断言一次,确认 latest 没有指向本次 tag。
name: GC-UI Alpha
on:
# 定时触发已取消:夜间构建会绕开 build.sh,产出不含后端/前端的空壳包,
# 且 cron 的 TZ= 前缀在部分 Gitea 版本上非法。需要时手动 dispatch。
workflow_dispatch:
inputs:
note:
description: '额外写进 Release 说明的备注(可留空)'
required: false
default: ''
# 用 github.token 往本仓库建 Release / 传附件,需要 contents 写权限
permissions:
contents: write
env:
GITEA_API: ${{ github.server_url }}/api/v1
REPO: ${{ github.repository }}
FRONTEND_DIR: GC-UI/frontend
# runner 上没预装 Flutter 时,按这个版本自举(需 >= 3.5.4,与 pubspec.yaml 的 sdk 约束对齐)
FLUTTER_VERSION: 3.24.5
jobs:
# ---------------------------------------------------------------- 1. 版本与草稿
prepare:
name: 计算 alpha 版本并创建预览版草稿
runs-on: ubuntu-latest
outputs:
version: ${{ steps.meta.outputs.version }}
base_version: ${{ steps.meta.outputs.base_version }}
tag: ${{ steps.meta.outputs.tag }}
build_number: ${{ steps.meta.outputs.build_number }}
release_id: ${{ steps.release.outputs.release_id }}
steps:
- name: 检出代码
uses: actions/checkout@v4
- name: 计算版本号
id: meta
run: |
set -euo pipefail
# 基础版本取自 version.json 的 launcher.version(例如 1.0.7),与启动器保持一致;
# alpha 后缀只表示构建通道,写在 tag / Release 标题里。
BASE=$(python3 -c "import json;print(json.load(open('version.json'))['launcher']['version'])")
if [ -z "${BASE:-}" ]; then
echo "::error::无法从 version.json 读取 launcher.version"
exit 1
fi
# 北京时间当天日期,让同一天的多次手动构建落在同一个日期前缀下
DATE=$(TZ=Asia/Shanghai date +%Y%m%d)
# 同一天重跑时用 run_number 区分,tag 不重复
VERSION="${BASE}-alpha.${DATE}.${{ github.run_number }}"
# 传给 flutter 的版本号必须是纯数字分段:
# --build-name → macOS CFBundleShortVersionString,只能是 a.b.c
# --build-number → CFBundleVersion / 文件版本号,只能是数字
# 所以 alpha 的日期与序号放在 build-number 里,不放进 build-name。
BUILD_NUMBER="${DATE}$(printf '%02d' "${{ github.run_number }}")"
{
echo "version=$VERSION"
echo "base_version=$BASE"
echo "tag=v$VERSION"
echo "build_number=$BUILD_NUMBER"
} >> "$GITHUB_OUTPUT"
echo "alpha 版本: $VERSION(build-name=$BASE, build-number=$BUILD_NUMBER)"
- name: 创建预览版草稿
id: release
env:
# 优先用仓库 Secrets 里的 RELEASE_TOKEN;没配就退回 Gitea 自动注入的 github.token。
# 某些实例上自动 token 没有 releases 写权限,那时只需在
# Settings → Actions → Secrets 加一个 RELEASE_TOKEN,不用改本文件。
TOKEN_OVERRIDE: ${{ secrets.RELEASE_TOKEN }}
TOKEN_DEFAULT: ${{ github.token }}
TAG: ${{ steps.meta.outputs.tag }}
VERSION: ${{ steps.meta.outputs.version }}
run: |
set -euo pipefail
TOKEN="${TOKEN_OVERRIDE:-$TOKEN_DEFAULT}"
if [ -z "${TOKEN:-}" ]; then
echo "::error::拿不到 Gitea token,无法创建 Release"
exit 1
fi
api="$GITEA_API/repos/$REPO"
auth=(-H "Authorization: token $TOKEN")
# 可重跑:同 tag 的旧发布先删掉(只会是同一天重跑留下的)
code=$(curl -sS -o /tmp/existing.json -w '%{http_code}' "${auth[@]}" "$api/releases/tags/$TAG")
if [ "$code" = "200" ]; then
old_id=$(python3 -c "import json;print(json.load(open('/tmp/existing.json'))['id'])")
echo "已存在同 tag 发布 id=$old_id,先删除"
curl -sS -X DELETE "${auth[@]}" "$api/releases/$old_id" >/dev/null
fi
# draft=true + prerelease=true:
# prerelease → 永不成为 latest
# draft → 两个平台都构建成功前不对外可见,由 publish 任务翻成 false
payload=$(python3 - "$TAG" "$VERSION" "${{ github.sha }}" "${{ github.server_url }}" <<'PY'
import json, sys
tag, version, sha, server = sys.argv[1:5]
short = sha[:7]
body = (
"GC-UI alpha 构建(手动触发,**预览版 / prerelease**)。\n\n"
"- 版本:`%s`\n"
"- 提交:`%s`\n"
"- 构建来源:%s/commit/%s\n"
"- 通道:alpha —— 手动触发(定时任务已取消)\n\n"
"产物说明:\n\n"
"| 文件 | 平台 | 内容 |\n"
"|---|---|---|\n"
"| `gc-ui-alpha-windows-x64.zip` | Windows x64 | Flutter 前端 release 目录 |\n"
"| `gc-ui-alpha-macos-<arch>.zip` | macOS | `gc_ui.app` 应用包 |\n\n"
"这是前端产物,运行时需要配合 `GC-UI/backend/GC.UI.Server` 后端(默认 `127.0.0.1:17890`)。\n"
"未做代码签名,首次运行系统可能会提示。\n\n"
"> 本发布不是 latest:prerelease 的版本不会出现在「最新版本」里。\n"
) % (version, short, server, sha)
print(json.dumps({
"tag_name": tag,
"target_commitish": sha,
"name": "GC-UI Alpha " + version,
"body": body,
"draft": True,
"prerelease": True,
}))
PY
)
resp=$(curl -sS -X POST "${auth[@]}" -H 'Content-Type: application/json' -d "$payload" "$api/releases")
rid=$(printf '%s' "$resp" | python3 -c "import json,sys;print(json.load(sys.stdin).get('id',''))" 2>/dev/null || true)
if [ -z "$rid" ]; then
echo "::error::创建 Release 失败: $resp"
exit 1
fi
echo "release_id=$rid" >> "$GITHUB_OUTPUT"
echo "已创建预览版草稿 id=$rid tag=$TAG"
# ---------------------------------------------------------------- 2. Windows
windows:
name: 构建 Windows 前端
needs: prepare
runs-on: windows-latest
steps:
- name: 检出代码
uses: actions/checkout@v4
- name: 准备 Flutter SDK
shell: pwsh
run: |
$ErrorActionPreference = 'Stop'
if (Get-Command flutter -ErrorAction SilentlyContinue) {
Write-Host 'runner 已自带 Flutter:'
flutter --version
} else {
Write-Host "runner 上没有 Flutter,按官方 SDK $env:FLUTTER_VERSION 自举"
$url = "https://storage.googleapis.com/flutter_infra_release/releases/stable/windows/flutter_windows_$env:FLUTTER_VERSION-stable.zip"
$zip = Join-Path $env:RUNNER_TEMP 'flutter.zip'
curl.exe -sSL --retry 3 -o $zip $url
if ($LASTEXITCODE -ne 0) { Write-Error "下载 Flutter SDK 失败: $url"; exit 1 }
Expand-Archive -Path $zip -DestinationPath $env:RUNNER_TEMP -Force
$flutterBin = Join-Path $env:RUNNER_TEMP 'flutter\bin'
$flutterBin | Out-File -FilePath $env:GITHUB_PATH -Append -Encoding utf8
$env:PATH = "$flutterBin;$env:PATH"
flutter --version
}
# Windows 桌面构建依赖 VS Build Tools 的「使用 C++ 的桌面开发」工作负载
$doctor = flutter doctor -v 2>&1 | Out-String
if ($doctor -notmatch 'Visual Studio') {
Write-Host '::warning::flutter doctor 没看到 Visual Studio,Windows 构建很可能失败'
}
Write-Host "PROCESSOR_ARCHITECTURE=$env:PROCESSOR_ARCHITECTURE"
- name: 构建前端(release)
shell: pwsh
env:
VERSION: ${{ needs.prepare.outputs.base_version }}
BUILD_NUMBER: ${{ needs.prepare.outputs.build_number }}
run: |
$ErrorActionPreference = 'Stop'
flutter config --no-analytics 2>&1 | Out-Null
Set-Location $env:FRONTEND_DIR
flutter pub get
if ($LASTEXITCODE -ne 0) { exit 1 }
flutter build windows --release --build-name=$env:VERSION --build-number=$env:BUILD_NUMBER
if ($LASTEXITCODE -ne 0) { exit 1 }
- name: 打包
id: pack
shell: pwsh
run: |
$ErrorActionPreference = 'Stop'
# x64 / arm64 的产物都在 build\windows\<arch>\runner\Release,直接找实际存在的那个
$out = Get-ChildItem "$env:FRONTEND_DIR\build\windows" -Directory -ErrorAction SilentlyContinue |
ForEach-Object { Join-Path $_.FullName 'runner\Release' } |
Where-Object { Test-Path $_ } |
Select-Object -First 1
if (-not $out) {
Write-Error "没有找到 Windows 产物目录($env:FRONTEND_DIR\build\windows\*\runner\Release)"
exit 1
}
$arch = if ($env:PROCESSOR_ARCHITECTURE -eq 'ARM64') { 'arm64' } else { 'x64' }
$name = "gc-ui-alpha-windows-$arch.zip"
New-Item -ItemType Directory -Force -Path dist | Out-Null
$zip = Join-Path (Get-Location) "dist\$name"
Compress-Archive -Path (Join-Path $out '*') -DestinationPath $zip -Force
Get-Item $zip | Format-List Name, Length
"asset=$zip" | Out-File -FilePath $env:GITHUB_OUTPUT -Append -Encoding utf8
"asset_name=$name" | Out-File -FilePath $env:GITHUB_OUTPUT -Append -Encoding utf8
- name: 上传到预览版
shell: pwsh
env:
TOKEN_OVERRIDE: ${{ secrets.RELEASE_TOKEN }}
TOKEN_DEFAULT: ${{ github.token }}
RELEASE_ID: ${{ needs.prepare.outputs.release_id }}
ASSET: ${{ steps.pack.outputs.asset }}
ASSET_NAME: ${{ steps.pack.outputs.asset_name }}
run: |
$ErrorActionPreference = 'Stop'
$token = if ($env:TOKEN_OVERRIDE) { $env:TOKEN_OVERRIDE } else { $env:TOKEN_DEFAULT }
if (-not $token) { Write-Error '拿不到 Gitea token'; exit 1 }
$url = "$env:GITEA_API/repos/$env:REPO/releases/$env:RELEASE_ID/assets?name=$env:ASSET_NAME"
curl.exe -sS -X POST -H "Authorization: token $token" -H "Content-Type: application/octet-stream" --data-binary "@$env:ASSET" $url
if ($LASTEXITCODE -ne 0) { exit 1 }
Write-Host "`n已上传 $env:ASSET_NAME"
# ---------------------------------------------------------------- 3. macOS
macos:
name: 构建 macOS 前端
needs: prepare
runs-on: macos-latest
steps:
- name: 检出代码
uses: actions/checkout@v4
- name: 准备 Flutter SDK
run: |
set -euo pipefail
if command -v flutter >/dev/null 2>&1; then
echo "runner 已自带 Flutter:"
flutter --version
else
echo "runner 上没有 Flutter,按官方 SDK $FLUTTER_VERSION 自举"
case "$(uname -m)" in
arm64) SUFFIX="macos_arm64" ;;
*) SUFFIX="macos" ;;
esac
URL="https://storage.googleapis.com/flutter_infra_release/releases/stable/${SUFFIX}/flutter_${SUFFIX}_${FLUTTER_VERSION}-stable.zip"
ZIP="$RUNNER_TEMP/flutter.zip"
curl -sSL --retry 3 -o "$ZIP" "$URL"
rm -rf "$RUNNER_TEMP/flutter"
unzip -q "$ZIP" -d "$RUNNER_TEMP"
echo "$RUNNER_TEMP/flutter/bin" >> "$GITHUB_PATH"
export PATH="$RUNNER_TEMP/flutter/bin:$PATH"
flutter --version
fi
xcodebuild -version || echo "::warning::没找到 xcodebuild,macOS 构建很可能失败"
- name: 构建前端(release)
env:
VERSION: ${{ needs.prepare.outputs.base_version }}
BUILD_NUMBER: ${{ needs.prepare.outputs.build_number }}
run: |
set -euo pipefail
flutter config --no-analytics || true
cd "$FRONTEND_DIR"
flutter pub get
flutter build macos --release --build-name="$VERSION" --build-number="$BUILD_NUMBER"
- name: 打包
id: pack
run: |
set -euo pipefail
APP="$FRONTEND_DIR/build/macos/Build/Products/Release/gc_ui.app"
if [ ! -d "$APP" ]; then
echo "::error::没有找到 macOS 产物: $APP"
exit 1
fi
case "$(uname -m)" in
arm64) ARCH=arm64 ;;
*) ARCH=x64 ;;
esac
NAME="gc-ui-alpha-macos-${ARCH}.zip"
mkdir -p dist
# 用 ditto 才能保真 .app 内的符号链接与权限,zip -r 会破坏 .app 结构
ditto -c -k --sequesterRsrc --keepParent "$APP" "dist/$NAME"
ls -lh "dist/$NAME"
{
echo "asset=dist/$NAME"
echo "asset_name=$NAME"
} >> "$GITHUB_OUTPUT"
- name: 上传到预览版
env:
TOKEN_OVERRIDE: ${{ secrets.RELEASE_TOKEN }}
TOKEN_DEFAULT: ${{ github.token }}
RELEASE_ID: ${{ needs.prepare.outputs.release_id }}
run: |
set -euo pipefail
TOKEN="${TOKEN_OVERRIDE:-$TOKEN_DEFAULT}"
if [ -z "${TOKEN:-}" ]; then
echo "::error::拿不到 Gitea token"
exit 1
fi
curl -sS -X POST \
-H "Authorization: token $TOKEN" \
-H "Content-Type: application/octet-stream" \
--data-binary "@${{ steps.pack.outputs.asset }}" \
"$GITEA_API/repos/$REPO/releases/$RELEASE_ID/assets?name=${{ steps.pack.outputs.asset_name }}"
echo
echo "已上传 ${{ steps.pack.outputs.asset_name }}"
# ---------------------------------------------------------------- 4. 发布预览版
publish:
name: 发布预览版(保持 prerelease,不占用 latest)
needs: [prepare, windows, macos]
runs-on: ubuntu-latest
steps:
- name: 把草稿翻成正式预览版
env:
TOKEN_OVERRIDE: ${{ secrets.RELEASE_TOKEN }}
TOKEN_DEFAULT: ${{ github.token }}
RELEASE_ID: ${{ needs.prepare.outputs.release_id }}
TAG: ${{ needs.prepare.outputs.tag }}
NOTE: ${{ github.event.inputs.note }}
run: |
set -euo pipefail
TOKEN="${TOKEN_OVERRIDE:-$TOKEN_DEFAULT}"
api="$GITEA_API/repos/$REPO"
auth=(-H "Authorization: token $TOKEN")
code=$(curl -sS -o /tmp/rel.json -w '%{http_code}' "${auth[@]}" "$api/releases/$RELEASE_ID")
if [ "$code" != "200" ]; then
echo "::error::读不到 Release $RELEASE_ID (HTTP $code)"
exit 1
fi
payload=$(python3 - /tmp/rel.json "${NOTE:-}" <<'PY'
import json, sys
rel = json.load(open(sys.argv[1]))
note = (sys.argv[2] or "").strip()
body = rel.get("body") or ""
if note:
body += "\n---\n\n备注:" + note + "\n"
print(json.dumps({
"body": body,
"draft": False, # 可见
"prerelease": True, # 关键:永不成为 latest
}))
PY
)
patched=$(curl -sS -X PATCH "${auth[@]}" -H 'Content-Type: application/json' -d "$payload" "$api/releases/$RELEASE_ID")
printf '%s' "$patched" > /tmp/patched.json
python3 - <<'PY'
import json
d = json.load(open('/tmp/patched.json'))
print('发布成功:', d.get('html_url'), '| prerelease =', d.get('prerelease'), '| draft =', d.get('draft'))
assert d.get('prerelease') is True, 'Release 没有被标记成 prerelease,会顶掉 latest'
assert d.get('draft') is False, 'Release 仍是草稿'
PY
- name: 断言 latest 未被占用
env:
TAG: ${{ needs.prepare.outputs.tag }}
run: |
set -euo pipefail
latest_tag=$(curl -sS "$GITEA_API/repos/$REPO/releases/latest" \
| python3 -c "import json,sys;print(json.load(sys.stdin).get('tag_name') or '')" || true)
echo "本次 tag: $TAG"
echo "latest 指向: ${latest_tag:-(空)}"
if [ "$latest_tag" = "$TAG" ]; then
echo "::error::本次 alpha 成了 latest,prerelease 标记失效"
exit 1
fi
echo "OK:alpha 未占用 latest"
-143
View File
@@ -1,143 +0,0 @@
# ---------------------------------------------------------------------------
# PR 审核流水线(Gitea Actions)
#
# 触发:向 main / gc-ui 提 PR(新建、追加提交、重新打开、取消草稿)时执行。
# 覆盖:后端编译、后端自检、前端静态分析 / 测试、依赖漏洞与硬编码密钥扫描,
# 最后用 review-gate 汇总,任意一项失败则整条流水线失败(阻止合并)。
# ---------------------------------------------------------------------------
name: PR 审核
on:
pull_request:
branches: [main, gc-ui]
types: [opened, synchronize, reopened, ready_for_review]
concurrency:
group: pr-check-${{ github.event.pull_request.number }}
cancel-in-progress: true
env:
# Avalonia 遥测任务在 CI 只读目录会写日志失败并中断编译(MSB4018)
AVALONIA_TELEMETRY_OPTOUT: '1'
DOTNET_NOLOGO: '1'
DOTNET_CLI_TELEMETRY_OPTOUT: '1'
jobs:
backend-build:
name: 后端编译
runs-on: ubuntu-latest
steps:
- name: 检出代码
uses: actions/checkout@v4
- name: 安装 .NET 8
uses: actions/setup-dotnet@v4
with:
dotnet-version: '8.0.x'
- name: 还原依赖
run: dotnet restore GC.sln
- name: 编译整个解决方案(Release)
run: dotnet build GC.sln -c Release --no-restore
- name: 编译 GC-UI 后端(前后端契约变更时单独验证)
run: dotnet build GC-UI/backend/GC.UI.Server/GC.UI.Server.csproj -c Release --no-restore
backend-test:
name: 后端自检
runs-on: ubuntu-latest
needs: backend-build
steps:
- name: 检出代码
uses: actions/checkout@v4
- name: 安装 .NET 8
uses: actions/setup-dotnet@v4
with:
dotnet-version: '8.0.x'
- name: 运行 GC.Tests(含离屏渲染 / 清单校验 / 日志用例)
run: dotnet run --project GC/src/test/dotnet/GC.Tests/GC.Tests.csproj -c Release
- name: 运行应用器测试(整目录替换 / .GC/bin 合并 / 回滚)
run: dotnet run --project GC/src/test/dotnet/GC.Savedog.Tests/GC.Savedog.Tests.csproj -c Release
frontend:
name: 前端检查(Flutter)
runs-on: ubuntu-latest
steps:
- name: 检出代码
uses: actions/checkout@v4
- name: 安装 Flutter
uses: subosito/flutter-action@v2
with:
channel: stable
cache: true
- name: 拉取依赖
working-directory: GC-UI/frontend
run: flutter pub get
- name: 静态分析
working-directory: GC-UI/frontend
run: flutter analyze --no-fatal-infos --no-fatal-warnings
- name: 单元 / 组件测试
working-directory: GC-UI/frontend
run: flutter test
security:
name: 安全扫描
runs-on: ubuntu-latest
steps:
- name: 检出代码
uses: actions/checkout@v4
- name: 安装 .NET 8
uses: actions/setup-dotnet@v4
with:
dotnet-version: '8.0.x'
- name: 依赖漏洞扫描(含传递依赖)
run: |
dotnet restore GC.sln
dotnet list GC.sln package --vulnerable --include-transitive
- name: 硬编码密钥 / 口令扫描
run: |
set +e
echo "扫描源码中的疑似明文口令 / 令牌…"
MATCHES=$(grep -rInE \
--include='*.cs' --include='*.dart' --include='*.yml' --include='*.yaml' \
--include='*.sh' --include='*.ps1' --include='*.json' \
'(password|passwd|secret|api[_-]?key|access[_-]?token)[[:space:]]*[:=][[:space:]]*["'\''][^"'\''[:space:]]{6,}' \
. 2>/dev/null | grep -vE 'example|placeholder|dummy|CHANGEME|YOUR_|\$\{\{')
if [ -n "$MATCHES" ]; then
echo "$MATCHES"
echo "::error::发现疑似硬编码凭据,请改用 Secrets 或环境变量"
exit 1
fi
echo "未发现硬编码凭据"
review-gate:
name: 审核汇总
runs-on: ubuntu-latest
needs: [backend-build, backend-test, frontend, security]
if: always()
steps:
- name: 检查各阶段结果
run: |
echo "后端编译: ${{ needs.backend-build.result }}"
echo "后端自检: ${{ needs.backend-test.result }}"
echo "前端检查: ${{ needs.frontend.result }}"
echo "安全扫描: ${{ needs.security.result }}"
if [ "${{ needs.backend-build.result }}" != "success" ] || \
[ "${{ needs.backend-test.result }}" != "success" ] || \
[ "${{ needs.frontend.result }}" != "success" ] || \
[ "${{ needs.security.result }}" != "success" ]; then
echo "::error::审核未通过:存在失败阶段,请修复后重新提交"
exit 1
fi
echo "审核通过:可以合并"
-50
View File
@@ -1,50 +0,0 @@
# ---------------------------------------------------------------------------
# 发布一致性核对(Gitea Actions)
#
# 触发:仅手动。发布前跑一次确认「tag / 清单 / 资产」互相对得上,发布后再跑一次
# 确认线上资产就是清单里那两份。
#
# 为什么不用 pull_request 触发:这里要下载几百 MB 的发布包,PR 阶段跑太贵;
# 需要时点 Run workflow 即可,本地也有等价命令:./build.sh release-verify <tag>
# ---------------------------------------------------------------------------
name: 发布核对
on:
workflow_dispatch:
inputs:
tag:
description: '要核对的 tag(如 1.1.0)'
required: true
skip_download:
description: '只比对体积、不下载校验 sha256(快,输入 1 开启)'
required: false
default: ''
env:
DOTNET_NOLOGO: '1'
DOTNET_CLI_TELEMETRY_OPTOUT: '1'
jobs:
verify:
name: 核对 Release 与清单
runs-on: ubuntu-latest
steps:
- name: 检出代码
uses: actions/checkout@v4
- name: 安装 .NET 8
uses: actions/setup-dotnet@v4
with:
dotnet-version: '8.0.x'
- name: 核对
env:
GC_GITEA_TOKEN: ${{ secrets.GC_GITEA_TOKEN }}
run: |
set -eu
EXTRA=""
if [ -n "${{ github.event.inputs.skip_download }}" ]; then
EXTRA="--skip-download"
fi
chmod +x buildsh/lib/verify_release.py
./build.sh release-verify "${{ github.event.inputs.tag }}" $EXTRA
+6 -42
View File
@@ -1,56 +1,20 @@
# 运行数据目录(settings/model/cache/update),绝不入库
.GC/
# 签名私钥:绝对不入库(公钥写在 GC/src/Security/SignatureKeyring.cs 里)
.signing/
# .NET 构建中间产物(已跟踪的历史文件不动,只防新增)
bin/
obj/
build/
.GC/
*.user
.DS_Store
.vs/
.venv/
venv/
env/
.idea/
.vscode/
.DS_Store
__pycache__/
*.pyc
*.pyo
*.log
node_modules/
dist/
build/
.pytest_cache/
.mypy_cache/
# ---- GC-UI(Flutter 前端)----
# Flutter / Dart 构建产物与本地工具状态
GC-UI/frontend/.dart_tool/
GC-UI/frontend/.flutter-plugins
GC-UI/frontend/.flutter-plugins-dependencies
GC-UI/frontend/.packages
GC-UI/frontend/build/
GC-UI/frontend/**/Flutter/ephemeral/
GC-UI/frontend/**/GeneratedPluginRegistrant.*
GC-UI/frontend/**/generated_plugin_registrant.*
GC-UI/frontend/**/generated_plugins.cmake
GC-UI/frontend/**/generated_plugins.h
GC-UI/frontend/**/generated_plugin_registrant.h
GC-UI/frontend/**/generated_plugin_registrant.cc
GC-UI/frontend/**/generated_plugin_registrant.swift
GC-UI/frontend/**/flutter_export_environment.sh
GC-UI/frontend/**/xcschemes/xcschememanagement.plist
GC-UI/frontend/**/Pods/
GC-UI/frontend/**/Podfile.lock
GC-UI/frontend/**/.symlinks/
GC-UI/frontend/**/Runner.xcworkspace/xcuserdata/
GC-UI/frontend/**/Runner.xcodeproj/xcuserdata/
GC-UI/frontend/**/Runner.xcodeproj/project.xcworkspace/xcuserdata/
GC-UI/frontend/**/DebugProfile.entitlements.bak
GC-UI/frontend/**/*.iml
GC-UI/frontend/test/shots/
# GC.Tests 离屏渲染输出(dotnet run ... GC.Tests 默认写到仓库根 screenshots/)
screenshots/
dist/
+40
View File
@@ -0,0 +1,40 @@
# 2026-11-07
## Earth Model Studio(新建项目)
- 用户要求:C#/.NET8(可切10),多目录结构(曾要求 gradle 命名,后明确改为标准 .NET 命名,勿再用 gradle 字样)
- 结构:src/main/dotnet + src/test/dotnet + src/main/resources + model/ + examples/ + dist/ + Directory.Build.props + build.sh/build.ps1
- 三平台一次性编译:`./build.sh publish` → dist/{mac-arm64(.app),win-x64,win-arm64},自包含单文件 + 内置 model/ + examples/
- 技术栈:Avalonia 11.3.9 + CommunityToolkit.Mvvm 8.2.2(本地 NuGet 已缓存);纯 CPU 球面像素渲染(SphereRaster + CelestialView)
- 模型格式:model/<id>/<id>.json + <id>.model/scene.json + land.json;模型源=git 仓库根的 model/ 目录(支持 github/gitlab/gitee zip 归档、git clone、本地目录)
- 内置模型:earth-rotation(自转)、earth-revolution(公转),land.json 手绘大陆轮廓已校验
- 校验:src/test/dotnet 用 Avalonia.Headless 渲染截图到 build/screenshots(页面+场景全通过,HUD 重叠已修)
- 已知小问题:RadialGradientBrush.Radius 过时警告;发布后 mac 单文件在沙箱内需 DOTNET_BUNDLE_EXTRACT_BASE_DIR 可写
## 修改(14:10 之后)
- 模型启动改为独立窗口:新增 Views/PlayerWindow.axaml(.cs),MainViewModel 只抛 PlayerRequested 事件,MainWindow 负责 Show(owner) 并维护 PlayerWindows 列表;PlayerViewModel 去掉 MainViewModel 依赖,改 CloseRequested + IDisposable;Esc/空格/F11 快捷键
- 分层:src=启动器(无模型数据、无预置模型源),model/=模型数据。移除 examples/,SettingsService 不再种内置源,AppPaths 去掉 ExamplesRoot 并新增 EMS_MODELS
- build.sh/build.ps1:publish 只建空 model/(仅 README),新增 pack-models → dist/models-1.0.0.zip
- model/README.md 写清模型格式规范
- 验证:离屏截图 page-player.png / page-main-while-playing.png,双窗口计数 2→关一个→1→0;三平台重新发布 + 模型 zip
## 架构重构(14:30 之后):启动器不再渲染,模型自带功能代码
- 新分层:src=启动器(扫描/下载/开窗,零渲染);model-sdk=契约;model-src=模型源码+封面工具;model=模型包(数据+dll+preview.png+i18n)
- 契约:IModelFactory(ApiVersion/Create) / IModelRuntime.CreateView(IModelContext) / IModelContext(ModelId/ModelDirectory/DataDirectory/Language/MemoryBudgetMb/RequestClose/Log)
- 加载:ModelHost + 可收集 AssemblyLoadContext,Sdk/Avalonia 走默认上下文,关窗 Unload
- 迁移:CelestialView/SphereRaster/LandMask/SceneDefinition/SceneRuntime → model-src/EarthModels(命名空间 NeoRF.EarthModels);PlayerView+PlayerViewModel 换成模型内 EarthModelView(C# 构建 UI)
- 模型包新增清单字段 assembly/type/preview/apiVersion;封面由 model-src/tools/PreviewGen 用模型渲染器生成
- 自转模型 views=["rotation"] → 无节气定位/无视图切换;公转 views=["revolution"] → 有节气、封面是公转场景
- 构建:./build.sh models 编译模型 dll + 生成封面;pack-models 先编译再打包
- 验证:EMS_SELFTEST=1 自检(dev + 发布包 /tmp 部署)两个模型均 OK;离屏截图含插件加载真实窗口
## 六项改动(15:00–15:35):真实贴图 / 缩放 / 拖动 / 动画 / 代码归位 / 进度条
- 目录:删除 model-src,根目录 model-sdk -> model/_sdk;现在根目录只有 src/ 与 model/。模型源码在 model/<id>/src/,共享引擎在 model/_engine/,契约在 model/_sdk/
- 清单 assembly 改为各模型自己的 dll:EarthRotationModel.dll / EarthRevolutionModel.dll(工厂仍是 NeoRF.EarthModels.*ModelFactory)
- 贴图:PlanetTexture 烘焙 1024×512 等经纬度纹理(海洋深度、沙漠/雨林/针叶林/苔原、极地冰盖、云层模糊、夜间辉光);反照率打包 uint[] Albedo
- 性能:地形梯度 SlopeEast/SlopeNorth 预烘焙(去掉每像素 4 次 SampleHeight + 6 次三角函数);海面高光 Pow 改乘法;运动时降分辨率 460 + 按帧耗时自适应 320–460,静止补 820 高清帧。实测公转播放 6ms、自转播放 ~18ms
- 交互:滚轮/工具栏 −100%+/⟲ 缩放 0.6–6×(缓动),暂停后拖动旋转地球或沿轨道移动、松手惯性;云层播放/暂停都缓慢漂移
- 动画:模型窗口淡入、按钮悬停 BrushTransition、教学面板滑入淡出;启动器页面切换淡入、按钮/卡片悬停过渡、进度条 DoubleTransition 平滑
- 进度条:契约新增 IModelRuntime.Prepare(后台)+ IModelContext.ReportProgress;ModelHost.LoadAsync 两阶段;LoadingWindow 显示真实阶段(读场景→烘焙纹理→构建界面)
- 打包:pack-models 排除 */bin/* */obj/*,避免把 107MB SkiaSharp native 打进包;模型包 356KB(含源码+dll+封面+i18n)
- 验证:离屏截图全部正常;反射校验缩放 1.00→1.25→1.00、暂停拖动=True、交互提示=True;自转无节气;发布包复制到 /tmp 自检两个模型 OK
- 产物:dist/mac-arm64 97M、win-x64 88M、win-arm64 94M(model/ 仅 README),dist/models-1.0.0.zip 356K
-29
View File
@@ -1,29 +0,0 @@
# 2026-11-14
## GC 启动器安全加固(补完)
- **GC-SAVEDOG 裁剪发布**:`PublishTrimmed=true` + `TrimMode=full` +
`JsonSerializerIsReflectionEnabledByDefault=false`(已写进 csproj 与两套构建脚本)。
体积 70MB → 14MB。裁剪后反射式 JSON 会失效,因此新增
`GC-SAVEDOG/SavedogJson.cs`(`JsonSerializerContext` 源生成)并通过
`Json.TypeInfoProvider` 钩子接进共享的 `GC.Download/GC.Services.Json`。
→ 新增 JSON 类型必须登记到 `SavedogJsonContext`,否则只有发布产物会炸。
- **构建产物布局改为 `dist/<系统>-<架构>/`**(mac-arm64 / win-amd64 / win-arm64),
更新包路径 `dist/<平台>/GC-<版本>-<平台>.zip`;`pack_launcher` 之后调
`VersionStamp --launcher-only` 把 `path/dir/name/sha256/size` 写进清单并重新签名。
原始 `.app`/`.exe` 移到 `build/trash/`(避免递归删除几百个文件)。
- **启动器更新支持「只发产物、不发 Release」**:新增 `GC-DOWNLOAD/LauncherArtifacts.cs`
(平台标签/别名、候选目录与文件名推导,构建端 VersionStamp 也链接同一份)。
`GitCodeRemote/GiteaRemote/DirectoryRemote.DownloadPackageAsync` 改成
多候选尝试:url → 清单 path → `dist/<系统>-<架构>/` 目录扫描 → dist 根目录命名,
每个候选都必须匹配已签名清单的 sha256。
`GitCodeReleaseRemote` 在「没有 Release」时不再清空 launcher 字段(清单已签名)。
- **测试**:`--update-test` 新增两条用例(dist 目录能找到并下载 / dist 目录里哈希不符被拒绝),
当前 33 项全部通过。
- 触发过的坑:`rm -rf` 大批文件被沙箱批量删除保护拦截 → 构建脚本改用 `mv` 到 `build/trash`。
- **收尾验证(19:35–19:37)**:`./build.sh pack-launcher` 24s 完成三平台打包,
清单已写入真实 `sha256/size`(win-amd64 44MB / win-arm64 42MB / mac-arm64 8.7MB,
osx-x64 与 linux-amd64 无产物故留空,下载端会跳过)。根 `version.json` 与
`model/version.json` 字节一致、签名 `gc-2026-11` 校验 Verified。
从 mac 包里解出的 GC-SAVEDOG(14MB 裁剪版)实跑 `verify` / `status` 正常;
`./build.sh check` 全流程通过。
+5 -6
View File
@@ -1,9 +1,8 @@
<Project>
<!--
多目录结构公共属性:
GC-BOOT 启动入口
GC/src/ 启动器核心代码
GC/src/test/dotnet/<module> 测试 / 离屏渲染校验
src/main/dotnet/<module> 生产代码
src/test/dotnet/<module> 测试 / 离屏渲染校验
TargetFramework 可由命令行覆盖:dotnet build -p:TargetFramework=net10.0
-->
<PropertyGroup Condition="'$(TargetFramework)' == ''">
@@ -22,9 +21,9 @@
-->
<AvaloniaVersion>11.3.9</AvaloniaVersion>
<MvvmVersion>8.2.2</MvvmVersion>
<Version>1.1.1</Version>
<Company>Morris</Company>
<Product>GC</Product>
<Version>1.0.2</Version>
<Company>NeoRF</Company>
<Product>Earth Model Studio</Product>
<NeutralLanguage>zh-Hans</NeutralLanguage>
</PropertyGroup>
</Project>
+13 -75
View File
@@ -3,21 +3,23 @@ Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 17
VisualStudioVersion = 17.0.31903.59
MinimumVisualStudioVersion = 10.0.40219.1
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "GC-BOOT", "GC-BOOT", "{827E0CD3-B72D-47B6-A68D-7590B98EB39B}"
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{827E0CD3-B72D-47B6-A68D-7590B98EB39B}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "GC-DOWNLOAD", "GC-DOWNLOAD", "{BCA2AA3E-F98F-43A1-9D31-239103C303F7}"
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "main", "main", "{ABAA6554-252E-13CE-1B40-0464A7DBA771}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GC-BOOT", "GC-BOOT\GC-BOOT.csproj", "{2E3BE2DB-1C4B-4EA0-9523-43EE910BD54C}"
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "dotnet", "dotnet", "{F2BBD9FE-F148-5687-ED21-3ABA515A9B22}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "GC", "GC", "{3E72BF5C-0B5E-D5BD-DCAE-6B991004B4A5}"
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "EarthModelStudio", "src\main\dotnet\EarthModelStudio\EarthModelStudio.csproj", "{2E3BE2DB-1C4B-4EA0-9523-43EE910BD54C}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{09578AA7-0862-3E52-D2AA-D8F7E863B74B}"
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "test", "test", "{3E72BF5C-0B5E-D5BD-DCAE-6B991004B4A5}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GC.Tests", "GC\src\test\dotnet\GC.Tests\GC.Tests.csproj", "{D15CB92F-5E5C-4516-8D07-C244FC0CD113}"
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "dotnet", "dotnet", "{09578AA7-0862-3E52-D2AA-D8F7E863B74B}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "EarthModelStudio.Tests", "src\test\dotnet\EarthModelStudio.Tests\EarthModelStudio.Tests.csproj", "{D15CB92F-5E5C-4516-8D07-C244FC0CD113}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "_sdk", "_sdk", "{26AABC0C-8B8D-F9B8-86B4-01B1A96D59F4}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GC.ModelSdk", "model\_sdk\GC.ModelSdk\GC.ModelSdk.csproj", "{C8FAB8D5-CAB7-42D7-8A1F-4B79771A2CE0}"
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "EarthModelStudio.ModelSdk", "model\_sdk\EarthModelStudio.ModelSdk\EarthModelStudio.ModelSdk.csproj", "{C8FAB8D5-CAB7-42D7-8A1F-4B79771A2CE0}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "model", "model", "{62B8A37E-7066-D91A-6443-87D4E6CE63FE}"
EndProject
@@ -33,20 +35,6 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{EADF0841-BEC
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "EarthRevolutionModel", "model\earth-revolution\src\EarthRevolutionModel.csproj", "{6BD9C21B-8F06-4F60-A087-696B6F03CC25}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GC.Core", "GC\src\GC.Core.csproj", "{AB63C416-5783-4FB9-A162-5BBA32E8BFCC}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "_sdk", "_sdk", "{6C38EF76-7D14-0C76-0B88-84F29EAA96CD}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GC-DOWNLOAD", "GC-DOWNLOAD\GC-DOWNLOAD.csproj", "{98F52FEA-43B5-4FE1-97A9-AF644AAFEFA3}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GC-SAVEDOG", "GC-SAVEDOG\GC-SAVEDOG.csproj", "{B169F2BF-9E60-40BF-824E-0486573DA65E}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "GC-UI", "GC-UI", "{560E034A-28FD-4D82-ABD0-FBD0C1B0F553}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "backend", "backend", "{59BED32E-68DD-4FA2-9A8E-89C71966F30E}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GC.UI.Server", "GC-UI\backend\GC.UI.Server\GC.UI.Server.csproj", "{33EA353C-FD81-4288-872E-D9404D9E50AF}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
@@ -117,60 +105,15 @@ Global
{6BD9C21B-8F06-4F60-A087-696B6F03CC25}.Release|x64.Build.0 = Release|Any CPU
{6BD9C21B-8F06-4F60-A087-696B6F03CC25}.Release|x86.ActiveCfg = Release|Any CPU
{6BD9C21B-8F06-4F60-A087-696B6F03CC25}.Release|x86.Build.0 = Release|Any CPU
{AB63C416-5783-4FB9-A162-5BBA32E8BFCC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{AB63C416-5783-4FB9-A162-5BBA32E8BFCC}.Debug|Any CPU.Build.0 = Debug|Any CPU
{AB63C416-5783-4FB9-A162-5BBA32E8BFCC}.Debug|x64.ActiveCfg = Debug|Any CPU
{AB63C416-5783-4FB9-A162-5BBA32E8BFCC}.Debug|x64.Build.0 = Debug|Any CPU
{AB63C416-5783-4FB9-A162-5BBA32E8BFCC}.Debug|x86.ActiveCfg = Debug|Any CPU
{AB63C416-5783-4FB9-A162-5BBA32E8BFCC}.Debug|x86.Build.0 = Debug|Any CPU
{AB63C416-5783-4FB9-A162-5BBA32E8BFCC}.Release|Any CPU.ActiveCfg = Release|Any CPU
{AB63C416-5783-4FB9-A162-5BBA32E8BFCC}.Release|Any CPU.Build.0 = Release|Any CPU
{AB63C416-5783-4FB9-A162-5BBA32E8BFCC}.Release|x64.ActiveCfg = Release|Any CPU
{AB63C416-5783-4FB9-A162-5BBA32E8BFCC}.Release|x64.Build.0 = Release|Any CPU
{AB63C416-5783-4FB9-A162-5BBA32E8BFCC}.Release|x86.ActiveCfg = Release|Any CPU
{AB63C416-5783-4FB9-A162-5BBA32E8BFCC}.Release|x86.Build.0 = Release|Any CPU
{98F52FEA-43B5-4FE1-97A9-AF644AAFEFA3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{98F52FEA-43B5-4FE1-97A9-AF644AAFEFA3}.Debug|Any CPU.Build.0 = Debug|Any CPU
{98F52FEA-43B5-4FE1-97A9-AF644AAFEFA3}.Debug|x64.ActiveCfg = Debug|Any CPU
{98F52FEA-43B5-4FE1-97A9-AF644AAFEFA3}.Debug|x64.Build.0 = Debug|Any CPU
{98F52FEA-43B5-4FE1-97A9-AF644AAFEFA3}.Debug|x86.ActiveCfg = Debug|Any CPU
{98F52FEA-43B5-4FE1-97A9-AF644AAFEFA3}.Debug|x86.Build.0 = Debug|Any CPU
{98F52FEA-43B5-4FE1-97A9-AF644AAFEFA3}.Release|Any CPU.ActiveCfg = Release|Any CPU
{98F52FEA-43B5-4FE1-97A9-AF644AAFEFA3}.Release|Any CPU.Build.0 = Release|Any CPU
{98F52FEA-43B5-4FE1-97A9-AF644AAFEFA3}.Release|x64.ActiveCfg = Release|Any CPU
{98F52FEA-43B5-4FE1-97A9-AF644AAFEFA3}.Release|x64.Build.0 = Release|Any CPU
{98F52FEA-43B5-4FE1-97A9-AF644AAFEFA3}.Release|x86.ActiveCfg = Release|Any CPU
{98F52FEA-43B5-4FE1-97A9-AF644AAFEFA3}.Release|x86.Build.0 = Release|Any CPU
{B169F2BF-9E60-40BF-824E-0486573DA65E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{B169F2BF-9E60-40BF-824E-0486573DA65E}.Debug|Any CPU.Build.0 = Debug|Any CPU
{B169F2BF-9E60-40BF-824E-0486573DA65E}.Debug|x64.ActiveCfg = Debug|Any CPU
{B169F2BF-9E60-40BF-824E-0486573DA65E}.Debug|x64.Build.0 = Debug|Any CPU
{B169F2BF-9E60-40BF-824E-0486573DA65E}.Debug|x86.ActiveCfg = Debug|Any CPU
{B169F2BF-9E60-40BF-824E-0486573DA65E}.Debug|x86.Build.0 = Debug|Any CPU
{B169F2BF-9E60-40BF-824E-0486573DA65E}.Release|Any CPU.ActiveCfg = Release|Any CPU
{B169F2BF-9E60-40BF-824E-0486573DA65E}.Release|Any CPU.Build.0 = Release|Any CPU
{B169F2BF-9E60-40BF-824E-0486573DA65E}.Release|x64.ActiveCfg = Release|Any CPU
{B169F2BF-9E60-40BF-824E-0486573DA65E}.Release|x64.Build.0 = Release|Any CPU
{B169F2BF-9E60-40BF-824E-0486573DA65E}.Release|x86.ActiveCfg = Release|Any CPU
{B169F2BF-9E60-40BF-824E-0486573DA65E}.Release|x86.Build.0 = Release|Any CPU
{33EA353C-FD81-4288-872E-D9404D9E50AF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{33EA353C-FD81-4288-872E-D9404D9E50AF}.Debug|Any CPU.Build.0 = Debug|Any CPU
{33EA353C-FD81-4288-872E-D9404D9E50AF}.Debug|x64.ActiveCfg = Debug|Any CPU
{33EA353C-FD81-4288-872E-D9404D9E50AF}.Debug|x64.Build.0 = Debug|Any CPU
{33EA353C-FD81-4288-872E-D9404D9E50AF}.Debug|x86.ActiveCfg = Debug|Any CPU
{33EA353C-FD81-4288-872E-D9404D9E50AF}.Debug|x86.Build.0 = Debug|Any CPU
{33EA353C-FD81-4288-872E-D9404D9E50AF}.Release|Any CPU.ActiveCfg = Release|Any CPU
{33EA353C-FD81-4288-872E-D9404D9E50AF}.Release|Any CPU.Build.0 = Release|Any CPU
{33EA353C-FD81-4288-872E-D9404D9E50AF}.Release|x64.ActiveCfg = Release|Any CPU
{33EA353C-FD81-4288-872E-D9404D9E50AF}.Release|x64.Build.0 = Release|Any CPU
{33EA353C-FD81-4288-872E-D9404D9E50AF}.Release|x86.ActiveCfg = Release|Any CPU
{33EA353C-FD81-4288-872E-D9404D9E50AF}.Release|x86.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
GlobalSection(NestedProjects) = preSolution
{2E3BE2DB-1C4B-4EA0-9523-43EE910BD54C} = {827E0CD3-B72D-47B6-A68D-7590B98EB39B}
{ABAA6554-252E-13CE-1B40-0464A7DBA771} = {827E0CD3-B72D-47B6-A68D-7590B98EB39B}
{F2BBD9FE-F148-5687-ED21-3ABA515A9B22} = {ABAA6554-252E-13CE-1B40-0464A7DBA771}
{2E3BE2DB-1C4B-4EA0-9523-43EE910BD54C} = {F2BBD9FE-F148-5687-ED21-3ABA515A9B22}
{3E72BF5C-0B5E-D5BD-DCAE-6B991004B4A5} = {827E0CD3-B72D-47B6-A68D-7590B98EB39B}
{09578AA7-0862-3E52-D2AA-D8F7E863B74B} = {3E72BF5C-0B5E-D5BD-DCAE-6B991004B4A5}
{D15CB92F-5E5C-4516-8D07-C244FC0CD113} = {09578AA7-0862-3E52-D2AA-D8F7E863B74B}
{C8FAB8D5-CAB7-42D7-8A1F-4B79771A2CE0} = {26AABC0C-8B8D-F9B8-86B4-01B1A96D59F4}
@@ -180,10 +123,5 @@ Global
{0B92F86C-37C2-3C12-904C-85123CE34F4C} = {62B8A37E-7066-D91A-6443-87D4E6CE63FE}
{EADF0841-BEC2-9A74-4322-069D7B5A6EBB} = {0B92F86C-37C2-3C12-904C-85123CE34F4C}
{6BD9C21B-8F06-4F60-A087-696B6F03CC25} = {EADF0841-BEC2-9A74-4322-069D7B5A6EBB}
{AB63C416-5783-4FB9-A162-5BBA32E8BFCC} = {09578AA7-0862-3E52-D2AA-D8F7E863B74B}
{6C38EF76-7D14-0C76-0B88-84F29EAA96CD} = {62B8A37E-7066-D91A-6443-87D4E6CE63FE}
{98F52FEA-43B5-4FE1-97A9-AF644AAFEFA3} = {BCA2AA3E-F98F-43A1-9D31-239103C303F7}
{59BED32E-68DD-4FA2-9A8E-89C71966F30E} = {560E034A-28FD-4D82-ABD0-FBD0C1B0F553}
{33EA353C-FD81-4288-872E-D9404D9E50AF} = {59BED32E-68DD-4FA2-9A8E-89C71966F30E}
EndGlobalSection
EndGlobal
-239
View File
@@ -1,239 +0,0 @@
using System;
using System.Diagnostics;
using System.IO;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using GC.UI.Server;
using Microsoft.AspNetCore.Builder;
namespace GC;
/// <summary>
/// 新界面启动壳。
///
/// 发布包带 <c>GC-UI</c>(Flutter 前端)时,启动器只做三件事:
/// 1. 在自己的进程里起后端(本地 HTTP API + 模型窗口宿主),等 <c>/api/health</c> 就绪;
/// 2. 拉起 Flutter 窗口;
/// 3. 界面退出后关掉后端。
///
/// 后端跑在进程内而不是单独一个 exe:两者用的是同一套 .NET 运行时,
/// 拆成两个自包含进程等于把 60MB 运行时复制两份,发布包会白白大一倍。
///
/// 缺 Flutter 前端时返回 <c>false</c>,由调用方回退到内置 Avalonia 界面——
/// 这样 `dotnet run`、只编了启动器的开发场景都能正常打开。
/// </summary>
internal static class FlutterShell
{
/// <summary>与前端、后端共用的默认端口(定义在 GC.Services.GcUiContract)。</summary>
private const int Port = Services.GcUiContract.DefaultPort;
private static readonly HttpClient Http = new() { Timeout = TimeSpan.FromSeconds(1.5) };
private static WebApplication? _backend;
public static bool TryRun(string[] args)
{
var dir = AppContext.BaseDirectory;
var uiPath = FindUi(dir);
if (uiPath == null) return false;
// 本次会话的一次性令牌:进程内后端与 Flutter 前端都从这里拿到同一个值。
// 只有我们拉起的后端才持有它,同机其他进程伪造的健康响应过不了 IsHealthy 的身份校验。
// 允许外部预设(自动化测试 / 高级部署固定令牌),未预设才现场生成随机值。
var token = Environment.GetEnvironmentVariable(Services.GcUiContract.TokenEnvVar);
if (string.IsNullOrEmpty(token)) token = Services.GcUiContract.NewSessionToken();
Environment.SetEnvironmentVariable(Services.GcUiContract.TokenEnvVar, token);
var port = Port;
AvaloniaHost? uiHost = null;
// 用户可能重复启动:只有当端口上已有一个「持有同一令牌」的后端时才复用。
// 同机其他程序即便占端口并返回 200,也没有令牌,会被 IsHealthy 拒绝,
// 于是我们改到下一个端口起自己的后端,绝不把前端交给伪装服务。
if (!IsHealthy(port, token))
{
// 端口可能被别的程序占用:17890 起向后试几个,选第一个能起来且健康的。
var start = Environment.GetEnvironmentVariable(Services.GcUiContract.PortEnvVar) is { Length: > 0 }
? Services.GcUiContract.PortFromEnvironment()
: Port;
for (var candidate = start; candidate < start + Services.GcUiContract.PortScanRange; candidate++)
{
var app = TryStartBackend(args, candidate, out var host);
if (app == null) continue;
if (WaitHealthy(candidate, token, TimeSpan.FromSeconds(25)))
{
port = candidate;
_backend = app;
uiHost = host;
break;
}
StopBackend(app);
}
if (_backend == null) return false;
}
AppDomain.CurrentDomain.ProcessExit += (_, _) => StopBackend(_backend);
var ui = Start(uiPath, dir, port, token);
if (ui == null)
{
StopBackend(_backend);
_backend = null;
return false;
}
// 前端窗口已拉起。模型窗口由 Avalonia 承载,而 macOS 的 AppKit 要求
// NSApplication 必须在**主线程**——所以事件循环要跑在这里(当前正是主线程),
// 不能再丢到副线程,否则一点「启动模型」就会把整个后端带崩。
ui.EnableRaisingEvents = true;
var closed = 0;
void RequestClose()
{
if (Interlocked.Exchange(ref closed, 1) == 1) return;
uiHost?.Shutdown();
}
ui.Exited += (_, _) => RequestClose();
if (ui.HasExited) RequestClose();
if (!ui.HasExited && uiHost != null)
{
// 阻塞直到界面退出(或图形环境初始化失败)。
uiHost.RunOnCurrentThread();
}
// Avalonia 起不来(无桌面会话)时仍要等界面退出,避免后端被提前收掉。
if (!ui.HasExited) ui.WaitForExit();
StopBackend(_backend);
_backend = null;
return true;
}
// ---------------------------------------------------------------- 产物定位
/// <summary>
/// Flutter 桌面产物。
/// macOS 是 <c>GC-UI.app/Contents/MacOS/GC-UI</c>;Windows 是 <c>GC-UI.exe</c>;
/// Linux 是 <c>GC-UI</c>。
/// </summary>
private static string? FindUi(string dir)
{
if (OperatingSystem.IsMacOS())
{
var exe = Path.Combine(dir, "GC-UI.app", "Contents", "MacOS", "GC-UI");
if (File.Exists(exe)) return exe;
}
foreach (var name in OperatingSystem.IsWindows() ? new[] { "GC-UI.exe" } : new[] { "GC-UI" })
{
var path = Path.Combine(dir, name);
if (File.Exists(path)) return path;
}
return null;
}
// ---------------------------------------------------------------- 进程管理
/// <summary>在本进程内启动后端;端口被占用等失败情况返回 null。</summary>
/// <param name="uiHost">成功时交出模型窗口宿主,由调用方在主线程跑事件循环。</param>
private static WebApplication? TryStartBackend(string[] args, int port, out AvaloniaHost? uiHost)
{
uiHost = null;
try
{
var app = BackendServer.Start(args, port, out var host);
uiHost = host;
app.StartAsync().GetAwaiter().GetResult();
return app;
}
catch (Exception ex)
{
Console.Error.WriteLine($"[shell] 后端启动失败(端口 {port}): {ex.Message}");
return null;
}
}
private static void StopBackend(WebApplication? app)
{
if (app == null) return;
try
{
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(3));
app.StopAsync(cts.Token).GetAwaiter().GetResult();
}
catch (Exception ex)
{
Console.Error.WriteLine($"[shell] 关闭后端失败: {ex.Message}");
}
}
private static Process Start(string fileName, string workingDirectory, int port, string token)
{
var info = new ProcessStartInfo(fileName)
{
WorkingDirectory = workingDirectory,
UseShellExecute = false,
};
// 把实际端口传给前端:它读这个环境变量拼 baseUrl,换端口不需要重新编译界面。
info.Environment[Services.GcUiContract.PortEnvVar] = port.ToString();
// 同一个会话令牌也交给前端,作为每个 /api 请求的身份凭证。
info.Environment[Services.GcUiContract.TokenEnvVar] = token;
// macOS .app 内的二进制也需要可执行位;发布包由 zip 解开时可能丢失。
if (!OperatingSystem.IsWindows())
{
try { File.SetUnixFileMode(fileName, UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute); }
catch { /* 权限不足时交给系统判断 */ }
}
return Process.Start(info)!;
}
// ---------------------------------------------------------------- 健康检查
/// <summary>
/// 健康探测必须带本次会话令牌:后端校验通过才说明这是「我们拉起的那个后端」。
/// 同机伪装进程即使返回 HTTP 200,也因为没有令牌而拿不到 200(后端会 401),
/// 但这里额外再比对响应体里的密钥指纹,双保险——即便对方原样回一个 200 也骗不过。
/// </summary>
private static bool IsHealthy(int port, string token)
{
try
{
using var request = new HttpRequestMessage(HttpMethod.Get, $"http://127.0.0.1:{port}/api/health");
request.Headers.TryAddWithoutValidation(Services.GcUiContract.TokenHeader, token);
using var response = Http.Send(request);
if (!response.IsSuccessStatusCode) return false;
// 状态码 200 还不够:伪装进程可能盲回一个 200。真正的后端会用会话令牌
// 派生指纹填进 health 响应,这里比对指纹确认对方确实持有同一个令牌。
var body = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
using var json = System.Text.Json.JsonDocument.Parse(body);
var proof = json.RootElement.TryGetProperty("sessionProof", out var p) ? p.GetString() : null;
var expected = Services.GcUiContract.DeriveSessionProof(token);
return string.Equals(proof, expected, StringComparison.OrdinalIgnoreCase);
}
catch
{
return false;
}
}
private static bool WaitHealthy(int port, string token, TimeSpan timeout)
{
var deadline = DateTime.UtcNow + timeout;
while (DateTime.UtcNow < deadline)
{
if (IsHealthy(port, token)) return true;
Thread.Sleep(250);
}
return false;
}
}
-31
View File
@@ -1,31 +0,0 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>WinExe</OutputType>
<Nullable>enable</Nullable>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<RootNamespace>GC.Boot</RootNamespace>
<AssemblyName>GC</AssemblyName>
<ApplicationManifest>app.manifest</ApplicationManifest>
<!-- 应用图标(Windows exe / 任务栏) -->
<ApplicationIcon>..\GC\src\Assets\icon.ico</ApplicationIcon>
<BuiltInComInteropSupport>true</BuiltInComInteropSupport>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Avalonia" Version="$(AvaloniaVersion)" />
<PackageReference Include="Avalonia.Desktop" Version="$(AvaloniaVersion)" />
</ItemGroup>
<ItemGroup>
<!-- 后端以库的方式编进启动器:发布包只需要一个 exe,不用再带一份运行时 -->
<FrameworkReference Include="Microsoft.AspNetCore.App" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\GC\src\GC.Core.csproj" />
<ProjectReference Include="..\GC-DOWNLOAD\GC-DOWNLOAD.csproj" />
<ProjectReference Include="..\GC-UI\backend\GC.UI.Server\GC.UI.Server.csproj" />
</ItemGroup>
</Project>
-257
View File
@@ -1,257 +0,0 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Sockets;
using System.Threading;
using System.Threading.Tasks;
namespace GC.Services;
/// <summary>
/// 本地目录源:用于离线教学(U 盘 / 共享盘里的仓库副本)与自动化测试。
/// 目录结构与远端仓库一致:version.json + model/&lt;id&gt;/...
/// </summary>
public sealed class DirectoryRemote : IModelRemote
{
private readonly string _root;
private static readonly HttpClient Http = new() { Timeout = TimeSpan.FromMinutes(5) };
private string? _rawManifest;
private string _launcherVersion = "";
public DirectoryRemote(string root) => _root = Path.GetFullPath(root);
public string DisplayName => _root;
public Task<RepoVersion?> GetVersionAsync(CancellationToken ct)
{
var primary = SafePath("version.json");
var fallback = SafePath(Path.Combine("model", "version.json"));
var file = File.Exists(primary) ? primary : fallback;
if (!File.Exists(file)) return Task.FromResult<RepoVersion?>(null);
// 离线目录同样验签:U 盘 / 共享盘里的清单也可能是被替换过的。
// 验签结论随 version.SignatureTrust 一起上送,由 UpdateService 按策略裁决;
// 这里至少要把失败如实记下来,不能静默丢弃(与 GiteaRemote/GitCodeRemote 保持一致)。
var text = File.ReadAllText(file);
_rawManifest = text;
var version = ManifestLoader.Parse(text, out var verification);
if (verification.Trust is ManifestTrust.Invalid or ManifestTrust.Unsigned)
Console.Error.WriteLine($"[directory] 清单验签失败({verification.Trust}): {verification.Error}");
if (version != null && !string.IsNullOrWhiteSpace(version.Launcher.Version))
_launcherVersion = version.Launcher.Version.Trim();
return Task.FromResult(version);
}
/// <summary>最近一次读到的清单原文(SAVEDOG 二次验签用)。</summary>
public Task<string?> GetRawVersionTextAsync(CancellationToken ct)
=> Task.FromResult(_rawManifest);
public Task<IReadOnlyList<RepoEntry>> ListTreeAsync(string rootPath, CancellationToken ct)
{
var baseDir = SafePath(rootPath ?? "model");
var result = new List<RepoEntry>();
if (!Directory.Exists(baseDir)) return Task.FromResult<IReadOnlyList<RepoEntry>>(result);
Walk(baseDir, baseDir, 0, result);
return Task.FromResult<IReadOnlyList<RepoEntry>>(result);
}
private void Walk(string dir, string baseDir, int depth, List<RepoEntry> result)
{
if (depth > 8) return;
foreach (var sub in Directory.GetDirectories(dir))
{
// 符号链接目录可能指向根目录之外:既不递归进去,也不作为条目暴露。
if (IsReparsePoint(sub)) continue;
var name = Path.GetFileName(sub);
if (name.StartsWith('.')) continue;
var rel = Relative(baseDir, sub);
result.Add(new RepoEntry
{
Name = name,
Path = Relative(_root, sub),
RelativePath = rel,
IsDirectory = true
});
Walk(sub, baseDir, depth + 1, result);
}
foreach (var file in Directory.GetFiles(dir))
{
if (IsReparsePoint(file)) continue;
var name = Path.GetFileName(file);
if (name.StartsWith('.')) continue;
result.Add(new RepoEntry
{
Name = name,
Path = Relative(_root, file),
RelativePath = Relative(baseDir, file),
IsDirectory = false,
Size = new FileInfo(file).Length
});
}
}
public async Task<byte[]> DownloadAsync(RepoEntry entry, CancellationToken ct)
=> await File.ReadAllBytesAsync(SafePath(entry.Path), ct);
public async Task<byte[]?> DownloadPackageAsync(RepoPackage package, CancellationToken ct)
{
// 清单路径 / dist 根目录命名:按仓库内相对路径直接找
foreach (var rel in LauncherArtifacts.CandidateFiles(
package.Rid, package.Dir, package.Path, package.Name, _launcherVersion))
{
string full;
try { full = SafePath(rel); }
catch (InvalidOperationException) { continue; }
if (File.Exists(full)) return await File.ReadAllBytesAsync(full, ct);
}
// dist/<系统>-<架构>/ 里放着的编译产物(与远端同一套查找规则):
// 本地源同样要能跑通「只发产物、不发 Release」的更新方式。
var fromDist = FindInDist(package);
if (fromDist != null) return await File.ReadAllBytesAsync(fromDist, ct);
var url = package.Url;
if (string.IsNullOrWhiteSpace(url)) return null;
// 清单里的 URL 属于外部输入,必须约束来源:
// · file:// 和绝对路径只允许读 _root 之内,杜绝任意本地文件读取;
// · 网络 URL 仅允许 http(s),且目标不能是环回/私有/链路本地/元数据地址,防 SSRF。
if (url!.StartsWith("file://", StringComparison.OrdinalIgnoreCase))
{
var local = new Uri(url).LocalPath;
return await File.ReadAllBytesAsync(SafePath(Path.GetRelativePath(_root, local)), ct);
}
if (Path.IsPathRooted(url))
{
if (File.Exists(url)) return await File.ReadAllBytesAsync(SafePath(Path.GetRelativePath(_root, url)), ct);
return null;
}
if (IsAllowedHttpUrl(url))
return await Http.GetByteArrayAsync(url, ct);
return null;
}
/// <summary>
/// 仅允许 http/https:挡住 file: 导致的任意本地文件读取和 gopher: 之类的协议滥用。
/// IP 字面量直接判公网;主机名(清单里的正常发布 URL)允许,但拒绝 localhost 与
/// 常见本地后缀,避免指向本机。域名解析到内网的情况由 HttpClient 侧的实际连接地址
/// 兜底——本地目录源的主路径本就是本地文件,网络只是兜底。
/// </summary>
private static bool IsAllowedHttpUrl(string url)
{
if (!Uri.TryCreate(url, UriKind.Absolute, out var uri)) return false;
if (uri.Scheme != Uri.UriSchemeHttp && uri.Scheme != Uri.UriSchemeHttps) return false;
if (uri.HostNameType == UriHostNameType.IPv4 || uri.HostNameType == UriHostNameType.IPv6)
return IsPublicAddress(uri.Host);
var host = uri.Host;
if (string.IsNullOrEmpty(host)) return false;
if (host.Equals("localhost", StringComparison.OrdinalIgnoreCase)) return false;
// 仅允许含点、且各段是字母数字/连字符的常规域名;拒绝 .local/.internal 等本地域。
if (host.EndsWith(".local", StringComparison.OrdinalIgnoreCase) ||
host.EndsWith(".localhost", StringComparison.OrdinalIgnoreCase) ||
host.EndsWith(".internal", StringComparison.OrdinalIgnoreCase))
return false;
foreach (var label in host.Split('.'))
if (label.Length == 0 || label[0] == '-' || label[^1] == '-' ||
!label.All(c => char.IsAsciiLetterOrDigit(c) || c == '-'))
return false;
return true;
}
private static bool IsPublicAddress(string host)
{
if (!IPAddress.TryParse(host, out var ip)) return false;
if (IPAddress.IsLoopback(ip) || IPAddress.Any.Equals(ip) || IPAddress.IPv6Any.Equals(ip)) return false;
if (ip.AddressFamily == AddressFamily.InterNetwork)
{
var b = ip.GetAddressBytes();
if (b[0] == 10 || b[0] == 127 || b[0] == 0) return false; // 私有 / 环回 / 本网
if (b[0] == 169 && b[1] == 254) return false; // 链路本地 / 云元数据
if (b[0] == 172 && b[1] >= 16 && b[1] <= 31) return false; // 私有
if (b[0] == 192 && b[1] == 168) return false; // 私有
if (b[0] == 100 && b[1] >= 64 && b[1] <= 127) return false; // CGNAT (IPv4 共享地址)
if (b[0] == 192 && b[1] == 0) return false; // IETF 协议分配
if (b[0] == 198 && (b[1] == 18 || b[1] == 19)) return false; // 基准测试
if (b[0] >= 224) return false; // 组播 / 保留
}
else if (ip.AddressFamily == AddressFamily.InterNetworkV6)
{
if (ip.IsIPv6LinkLocal || ip.IsIPv6SiteLocal || ip.IsIPv6Multicast) return false;
var b = ip.GetAddressBytes();
if (b[0] == 0xfd || b[0] == 0xfc) return false; // 唯一本地地址
if (ip.IsIPv4MappedToIPv6) return IsPublicAddress(ip.MapToIPv4().ToString());
}
return true;
}
/// <summary>在 dist/&lt;系统&gt;-&lt;架构&gt;/ 里找这个平台的启动器包;找不到返回 null。</summary>
private string? FindInDist(RepoPackage package)
{
foreach (var dir in LauncherArtifacts.CandidateDirs(package.Rid, package.Dir))
{
string full;
try { full = SafePath(dir); }
catch (InvalidOperationException) { continue; }
if (!Directory.Exists(full)) continue;
var zips = Directory.GetFiles(full, "*.zip");
if (zips.Length == 0) continue;
foreach (var zip in zips)
if (LauncherArtifacts.LooksLikePackage(Path.GetFileName(zip), _launcherVersion, package.Rid))
return zip;
if (zips.Length == 1) return zips[0];
}
return null;
}
/// <summary>把相对路径解析成 _root 内的真实路径:拒绝越界,且逐级拒绝符号链接。</summary>
private string SafePath(string relative)
{
var full = Path.GetFullPath(Path.Combine(_root, relative));
var prefix = _root.TrimEnd(Path.DirectorySeparatorChar) + Path.DirectorySeparatorChar;
if (!full.Equals(_root, StringComparison.OrdinalIgnoreCase) &&
!full.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
throw new InvalidOperationException($"路径越界: {relative}");
// 词法校验之后还要解析符号链接:root 内的链接可能指向根目录之外。
// 逐级检查 _root 到 full 的每一段,任何重解析点都直接拒绝。
var rel = Path.GetRelativePath(_root, full);
if (rel != "." && rel != "")
{
var cursor = _root;
foreach (var segment in rel.Split(Path.DirectorySeparatorChar, StringSplitOptions.RemoveEmptyEntries))
{
if (segment == "..") throw new InvalidOperationException($"路径越界: {relative}");
cursor = Path.Combine(cursor, segment);
if (IsReparsePoint(cursor))
throw new InvalidOperationException($"路径含符号链接,已拒绝: {relative}");
}
}
return full;
}
private static bool IsReparsePoint(string path)
{
try
{
if (!File.Exists(path) && !Directory.Exists(path)) return false;
return (File.GetAttributes(path) & FileAttributes.ReparsePoint) != 0;
}
catch
{
// 取不到属性时按不可信处理,避免绕过符号链接检查。
return true;
}
}
private static string Relative(string baseDir, string file) =>
Path.GetRelativePath(baseDir, file).Replace('\\', '/');
}
-50
View File
@@ -1,50 +0,0 @@
using System;
using System.Threading;
using System.Threading.Tasks;
using GC.Models;
using GC.Services;
namespace GC.Download;
public sealed class DownloadModuleFactory : IDownloadModuleFactory
{
public IDownloadModule Create(AppPaths paths, SettingsService settings, ModelRepository models) =>
new DownloadModule(paths, settings, models);
public bool TryApplyPending(AppPaths paths) => LauncherUpdater.TryApplyPending(paths);
}
internal sealed class DownloadModule : IDownloadModule
{
public IDownloadCenter Downloads { get; }
public IModelSourceClient Sources { get; }
public IUpdateService Updates { get; }
public ISourceSelector Selector { get; }
public ILauncherUpdateService LauncherUpdates { get; }
public DownloadModule(AppPaths paths, SettingsService settings, ModelRepository models)
{
Sources = new ModelSourceClient(paths);
Downloads = new DownloadCenter(paths, models);
Selector = new SourceSelector();
Updates = new UpdateService(paths, settings, UpdateService.CreateRemote(settings.Current));
LauncherUpdates = new LauncherUpdateService();
}
public IModelRemote CreateRemote(SourcePreset preset) => SourceSelector.CreateRemote(preset);
}
internal sealed class LauncherUpdateService : ILauncherUpdateService
{
public Task<string?> CheckAsync(IModelRemote remote, CancellationToken ct = default) =>
LauncherUpdater.CheckAsync(remote, ct);
public Task<UpdateRunResult> DownloadAsync(AppPaths paths, IModelRemote remote,
IProgress<UpdateProgressInfo>? progress = null, CancellationToken ct = default) =>
LauncherUpdater.DownloadAsync(paths, remote, progress, ct);
public bool ScheduleApply(AppPaths paths, string packageName) =>
LauncherUpdater.ScheduleApply(paths, packageName);
public bool TryApplyPending(AppPaths paths) => LauncherUpdater.TryApplyPending(paths);
}
-14
View File
@@ -1,14 +0,0 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<Nullable>enable</Nullable>
<RootNamespace>GC.Download</RootNamespace>
<AssemblyName>GC.Download</AssemblyName>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="CommunityToolkit.Mvvm" Version="$(MvvmVersion)" />
<ProjectReference Include="..\GC\src\GC.Core.csproj" />
</ItemGroup>
</Project>
-454
View File
@@ -1,454 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Security.Cryptography;
using System.Text;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
namespace GC.Services;
/// <summary>
/// gitcode 仓库源。默认地址来自 AppSettings.UpdateRepository
/// (https://gitcode.com/Morris_1/GC),可改成任意 gitcode 仓库或
/// https://gitcode.com/&lt;owner&gt;/&lt;repo&gt;/tree/&lt;branch&gt;/model 这样的地址。
/// 匿名访问 v5 contents API:目录 -> 数组,文件 -> { content: base64 };
/// 文件项自带 download_url(raw.gitcode.com/blobs/&lt;sha&gt;/...),可直接下载二进制。
/// </summary>
public sealed class GitCodeRemote : IModelRemote
{
public const string DefaultRepository = "https://gitcode.com/Morris_1/GC";
private readonly HttpClient _http;
private readonly string _api;
private readonly string _branch;
private readonly string _versionUrl;
private readonly string? _fallbackUrl;
private readonly string _displayName;
private string _modelDir = "model";
private string? _rawManifest;
/// <summary>最近一次读到的启动器版本号,用于推导 dist 目录里的包名。</summary>
private string _launcherVersion = "";
public string DisplayName => _displayName;
public GitCodeRemote(string? manifestUrl = null, string? repository = null)
{
var (owner, repo, branch) = ParseRepository(repository);
_branch = branch;
_api = $"https://api.gitcode.com/api/v5/repos/{owner}/{repo}/contents/";
_displayName = string.IsNullOrWhiteSpace(repository)
? DefaultRepository : repository!.TrimEnd('/');
_http = new HttpClient { Timeout = TimeSpan.FromMinutes(2) };
_http.DefaultRequestHeaders.UserAgent.ParseAdd("GC-Updater/1.0");
_http.DefaultRequestHeaders.Accept.ParseAdd("application/json");
if (string.IsNullOrWhiteSpace(manifestUrl))
{
_versionUrl = _api + "version.json?ref=" + _branch;
_fallbackUrl = _api + "model/version.json?ref=" + _branch;
}
else
{
_versionUrl = manifestUrl!;
_fallbackUrl = null;
}
}
/// <summary>从仓库 URL 解析 owner / repo / branch,解析失败回退到默认仓库。</summary>
private static (string Owner, string Repo, string Branch) ParseRepository(string? url)
{
var raw = string.IsNullOrWhiteSpace(url) ? DefaultRepository : url!.Trim();
if (!Uri.TryCreate(raw, UriKind.Absolute, out var uri))
return ("Morris_1", "GC", "main");
var parts = uri.AbsolutePath.Trim('/').Split('/', StringSplitOptions.RemoveEmptyEntries);
if (parts.Length < 2) return ("Morris_1", "GC", "main");
var owner = parts[0];
var repo = parts[1].EndsWith(".git", StringComparison.OrdinalIgnoreCase)
? parts[1][..^4] : parts[1];
var branch = parts.Length >= 4 && parts[2].Equals("tree", StringComparison.OrdinalIgnoreCase)
? parts[3] : "main";
return (owner, repo, branch);
}
public async Task<RepoVersion?> GetVersionAsync(CancellationToken ct)
{
RepoVersion? version = await ReadVersionFromAsync(_versionUrl, ct);
if (version == null && _fallbackUrl != null)
version = await ReadVersionFromAsync(_fallbackUrl, ct);
if (version != null && !string.IsNullOrWhiteSpace(version.ModelDir))
_modelDir = version.ModelDir.Trim('/');
if (version != null && !string.IsNullOrWhiteSpace(version.Launcher.Version))
_launcherVersion = version.Launcher.Version.Trim();
return version;
}
/// <summary>最近一次读到的清单原文(SAVEDOG 二次验签用)。</summary>
public Task<string?> GetRawVersionTextAsync(CancellationToken ct)
=> Task.FromResult(_rawManifest);
/// <summary>
/// 由 Release 覆盖版本号后同步一次,保证 dist 目录里的包名推导用的是
/// 「真正要装的那个版本」,而不是仓库清单里可能滞后的版本号。
/// </summary>
internal void SetLauncherVersion(string? version)
{
if (!string.IsNullOrWhiteSpace(version)) _launcherVersion = version!.Trim();
}
private async Task<RepoVersion?> ReadVersionFromAsync(string url, CancellationToken ct)
{
string text;
try
{
// 离线 / 网络不通时最多等 10 秒,不能让启动界面一直卡在「检查更新」
using var timeout = CancellationTokenSource.CreateLinkedTokenSource(ct);
timeout.CancelAfter(TimeSpan.FromSeconds(10));
text = await _http.GetStringAsync(url, timeout.Token);
}
catch (HttpRequestException) { return null; }
catch (OperationCanceledException) when (!ct.IsCancellationRequested) { return null; }
var trimmed = text.TrimStart();
if (trimmed.Length == 0 || trimmed[0] != '{') return null;
try
{
using var doc = JsonDocument.Parse(text);
var payload = text;
if (doc.RootElement.TryGetProperty("encoding", out _) &&
doc.RootElement.TryGetProperty("content", out var content))
{
var raw = Convert.FromBase64String(content.GetString() ?? "");
payload = Encoding.UTF8.GetString(raw);
}
if (!payload.TrimStart().StartsWith("{", StringComparison.Ordinal)) return null;
// 验签与解析一起做:拿到的清单必须能说明「它是不是可信的」
var version = ManifestLoader.Parse(payload, out var verification);
if (version == null) return null;
// 404 / 错误页也可能返回一个 JSON 对象,用 generated 确认这确实是版本清单
if (string.IsNullOrWhiteSpace(version.Generated)) return null;
if (verification.Trust == ManifestTrust.Invalid)
{
Console.Error.WriteLine($"[gitcode] 清单验签失败,已拒绝: {verification.Error}");
return null;
}
if (version != null && !string.IsNullOrWhiteSpace(version.Generated))
_rawManifest = payload;
return version;
}
catch (Exception ex)
{
Console.Error.WriteLine($"版本清单解析失败 {url}: {ex.Message}");
return null;
}
}
/// <summary>
/// 递归列出目录树(含目录项与文件项)。
/// 每个子目录一次 HTTP 请求,因此并行展开同一层的所有目录,
/// 否则 3 个模型、十几个目录串行请求会非常慢。
/// </summary>
public async Task<IReadOnlyList<RepoEntry>> ListTreeAsync(string rootPath, CancellationToken ct)
{
var result = new List<RepoEntry>();
var bag = new System.Collections.Concurrent.ConcurrentBag<RepoEntry>();
var repoPath = (rootPath ?? _modelDir).Trim('/');
await WalkParallelAsync(repoPath, "", 0, bag, ct);
// 稳定排序:目录在前、按路径字典序,保证调用方拿到确定顺序
result = bag.OrderBy(e => e.IsDirectory ? 0 : 1)
.ThenBy(e => e.RelativePath, StringComparer.Ordinal)
.ToList();
return result;
}
private async Task WalkParallelAsync(string repoPath, string relative, int depth,
System.Collections.Concurrent.ConcurrentBag<RepoEntry> bag, CancellationToken ct)
{
if (depth > 8) return;
var url = _api + repoPath + "?ref=" + _branch;
string text;
try { text = await GetWithRetryAsync(url, ct); }
catch (Exception ex)
{
Console.Error.WriteLine($"列目录失败 {repoPath}: {ex.Message}");
return;
}
if (!text.TrimStart().StartsWith("[", StringComparison.Ordinal)) return;
var subDirs = new List<(string Path, string Relative)>();
using (var doc = JsonDocument.Parse(text))
{
foreach (var item in doc.RootElement.EnumerateArray())
{
ct.ThrowIfCancellationRequested();
var name = Str(item, "name");
if (string.IsNullOrEmpty(name) || name.StartsWith('.')) continue;
// 这些目录不是模型运行数据,跳过可显著减少请求
// (模型目录里常见的 src/ bin/ obj/ 是源码与构建产物)
if (IsIgnoredDir(name)) continue;
var path = Str(item, "path");
if (string.IsNullOrWhiteSpace(path)) path = repoPath + "/" + name;
var isDir = Str(item, "type") == "dir";
var childRelative = relative.Length == 0 ? name : relative + "/" + name;
bag.Add(new RepoEntry
{
Name = name,
Path = path!,
RelativePath = childRelative,
IsDirectory = isDir,
DownloadUrl = NullableStr(item, "download_url"),
Sha = NullableStr(item, "sha"),
Size = Num(item, "size")
});
if (isDir) subDirs.Add((path!, childRelative));
}
}
if (subDirs.Count == 0) return;
// 同层并行;并发保持很低——GitCode API 对突发请求会返回 429
using var gate = new SemaphoreSlim(2);
var tasks = subDirs.Select(async d =>
{
await gate.WaitAsync(ct);
try { await WalkParallelAsync(d.Path, d.Relative, depth + 1, bag, ct); }
finally { gate.Release(); }
});
await Task.WhenAll(tasks);
}
private async Task WalkAsync(string repoPath, string relative, int depth,
List<RepoEntry> result, CancellationToken ct)
{
if (depth > 8) return;
var url = _api + repoPath + "?ref=" + _branch;
var text = await _http.GetStringAsync(url, ct);
if (!text.TrimStart().StartsWith("[", StringComparison.Ordinal)) return;
using var doc = JsonDocument.Parse(text);
foreach (var item in doc.RootElement.EnumerateArray())
{
ct.ThrowIfCancellationRequested();
var name = Str(item, "name");
if (string.IsNullOrEmpty(name) || name.StartsWith('.')) continue;
var path = Str(item, "path");
if (string.IsNullOrWhiteSpace(path)) path = repoPath + "/" + name;
var isDir = Str(item, "type") == "dir";
var childRelative = relative.Length == 0 ? name : relative + "/" + name;
result.Add(new RepoEntry
{
Name = name,
Path = path!,
RelativePath = childRelative,
IsDirectory = isDir,
DownloadUrl = NullableStr(item, "download_url"),
Sha = NullableStr(item, "sha"),
Size = Num(item, "size")
});
if (isDir) await WalkAsync(path!, childRelative, depth + 1, result, ct);
}
}
/// <summary>遍历时忽略的目录:源码与构建产物不属于模型运行数据。</summary>
private static bool IsIgnoredDir(string name) => name switch
{
"src" => true,
"bin" => true,
"obj" => true,
"node_modules" => true,
".git" => true,
".vs" => true,
_ => false
};
/// <summary>
/// 带退避重试的 GET。GitCode API 对突发请求返回 429,
/// 这里做 3 次指数退避,避免并行遍历时直接失败。
/// </summary>
private async Task<string> GetWithRetryAsync(string url, CancellationToken ct,
int maxAttempts = 3)
{
for (var attempt = 1; ; attempt++)
{
try
{
return await _http.GetStringAsync(url, ct);
}
catch (HttpRequestException ex) when (attempt < maxAttempts)
{
// 429 / 5xx 才重试,其余直接抛
var retriable = ex.StatusCode is null ||
(int)ex.StatusCode == 429 ||
(int)ex.StatusCode >= 500;
if (!retriable) throw;
await Task.Delay(TimeSpan.FromMilliseconds(400 * attempt * attempt), ct);
}
}
}
public async Task<byte[]> DownloadAsync(RepoEntry entry, CancellationToken ct)
{
if (!string.IsNullOrWhiteSpace(entry.DownloadUrl))
return await _http.GetByteArrayAsync(entry.DownloadUrl!, ct);
var url = _api + entry.Path.Trim('/') + "?ref=" + _branch;
var text = await _http.GetStringAsync(url, ct);
using var doc = JsonDocument.Parse(text);
if (!doc.RootElement.TryGetProperty("content", out var content))
throw new InvalidOperationException($"远端文件没有内容: {entry.Path}");
return Convert.FromBase64String(content.GetString() ?? "");
}
public async Task<byte[]?> DownloadPackageAsync(RepoPackage package, CancellationToken ct)
{
// 先试清单直给的 url(Release 附件):命中的情况下不多发任何一次 API 请求。
var direct = await TryFetchAsync(package.Url, package.Sha256, ct);
if (direct != null) return direct;
// url 不可用或校验不符:再去找仓库里的编译产物。
// 顺序:清单 path → dist/<系统>-<架构>/ 里的 zip → dist 根目录命名。
// 每个候选都要和已签名清单的 sha256 对一遍,对不上就换下一个,
// 因此「多来源」不放宽校验,只是让「不发 Release 也能更新」成立。
foreach (var path in LauncherArtifacts.CandidateFiles(
package.Rid, package.Dir, package.Path, package.Name, _launcherVersion))
{
var url = await ResolveFileUrlAsync(path, ct);
var bytes = await TryFetchAsync(url, package.Sha256, ct);
if (bytes != null) return bytes;
}
foreach (var dir in LauncherArtifacts.CandidateDirs(package.Rid, package.Dir))
{
var url = await FindZipInDirAsync(dir, package, ct);
var bytes = await TryFetchAsync(url, package.Sha256, ct);
if (bytes != null) return bytes;
}
Console.Error.WriteLine("[gitcode] 找不到可用的启动器包(Release 附件与 dist 目录都没对上)");
return null;
}
/// <summary>下载一个候选地址;<paramref name="sha256"/> 非空时必须与内容一致。</summary>
private async Task<byte[]?> TryFetchAsync(string? url, string? sha256, CancellationToken ct)
{
if (string.IsNullOrWhiteSpace(url)) return null;
byte[] bytes;
try { bytes = await _http.GetByteArrayAsync(url!, ct); }
catch (Exception ex)
{
Console.Error.WriteLine($"[gitcode] 下载失败 {Short(url!)}: {ex.Message}");
return null;
}
if (bytes.Length == 0) return null;
if (!string.IsNullOrWhiteSpace(sha256))
{
var actual = Convert.ToHexString(SHA256.HashData(bytes)).ToLowerInvariant();
if (!string.Equals(actual, sha256.Trim(), StringComparison.OrdinalIgnoreCase))
{
Console.Error.WriteLine($"[gitcode] 包校验不符,换下一个来源: {Short(url!)}");
return null;
}
}
Console.WriteLine($"[gitcode] 启动器包来源: {Short(url!)}");
return bytes;
}
private static string Short(string url)
=> url.Length <= 96 ? url : url[..60] + "…" + url[^24..];
/// <summary>把仓库内路径解析成直链;路径不存在或其实是目录时返回 null。</summary>
private async Task<string?> ResolveFileUrlAsync(string path, CancellationToken ct)
{
try
{
var url = _api + path.Trim('/') + "?ref=" + _branch;
var text = await _http.GetStringAsync(url, ct);
if (!text.TrimStart().StartsWith("{", StringComparison.Ordinal)) return null;
using var doc = JsonDocument.Parse(text);
if (doc.RootElement.TryGetProperty("type", out var type) &&
string.Equals(type.GetString(), "dir", StringComparison.OrdinalIgnoreCase))
return null;
return doc.RootElement.TryGetProperty("download_url", out var dl)
? dl.GetString() : null;
}
catch (Exception)
{
return null; // 404 / 网络问题都当作「这个路径没有」
}
}
/// <summary>
/// 在 <paramref name="dir"/> 里找启动器包。
/// 先按「版本 + 平台」精确筛,其次接受目录里唯一的 zip(发布者可能改了命名规则),
/// 最终仍由 sha256 兜底。
/// </summary>
private async Task<string?> FindZipInDirAsync(string dir, RepoPackage package, CancellationToken ct)
{
try
{
var url = _api + dir.Trim('/') + "?ref=" + _branch;
var text = await _http.GetStringAsync(url, ct);
if (!text.TrimStart().StartsWith("[", StringComparison.Ordinal)) return null;
var zips = new List<(string Path, string Name)>();
using (var doc = JsonDocument.Parse(text))
{
foreach (var item in doc.RootElement.EnumerateArray())
{
if (Str(item, "type") != "file") continue;
var name = Str(item, "name");
if (!name.EndsWith(".zip", StringComparison.OrdinalIgnoreCase)) continue;
var path = Str(item, "path");
zips.Add((path.Length > 0 ? path : dir + "/" + name, name));
}
}
if (zips.Count == 0) return null;
var version = _launcherVersion;
var match = zips.FindIndex(z =>
LauncherArtifacts.LooksLikePackage(z.Name, version, package.Rid));
if (match < 0)
{
if (zips.Count != 1) return null;
match = 0;
}
Console.WriteLine($"[gitcode] 在 {dir} 找到编译产物: {zips[match].Name}");
return await ResolveFileUrlAsync(zips[match].Path, ct);
}
catch (Exception)
{
return null;
}
}
private static string Str(JsonElement item, string name)
=> item.TryGetProperty(name, out var v) && v.ValueKind == JsonValueKind.String
? v.GetString() ?? "" : "";
private static string? NullableStr(JsonElement item, string name)
=> item.TryGetProperty(name, out var v) && v.ValueKind == JsonValueKind.String
? v.GetString() : null;
private static long Num(JsonElement item, string name)
=> item.TryGetProperty(name, out var v) && v.ValueKind == JsonValueKind.Number
&& v.TryGetInt64(out var n) ? n : 0;
}
-342
View File
@@ -1,342 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
namespace GC.Services;
/// <summary>
/// Gitea / Forgejo 后端(Xhmcl 用的就是这个)。
///
/// · 目录:GET /api/v1/repos/{owner}/{repo}/contents/{path}
/// 返回数组(目录)或对象(单文件),带 name/path/size/type/download_url
/// · 原始文件:GET {host}/{owner}/{repo}/raw/branch/{branch}/{path}
/// · Release:GET /api/v1/repos/{owner}/{repo}/releases
/// 版本取 tag_name;附件取 assets[].browser_download_url
///
/// Release 为空时(仓库还没发布),回退到仓库里的 version.json,保证只推仓库也能更新。
/// </summary>
public sealed class GiteaRemote : IModelRemote
{
private readonly SourcePreset _preset;
private static readonly HttpClient Http = CreateHttp();
private string? _rawManifest;
private static HttpClient CreateHttp()
{
var c = new HttpClient { Timeout = TimeSpan.FromSeconds(20) };
c.DefaultRequestHeaders.UserAgent.ParseAdd("GC-Updater/1.0");
c.DefaultRequestHeaders.Accept.ParseAdd("application/json");
return c;
}
public GiteaRemote(SourcePreset preset)
{
_preset = preset;
DisplayName = preset.Name;
}
public string DisplayName { get; }
public string SourceId => _preset.Id;
private string RepoApi => $"{_preset.ApiBase}/repos/{_preset.Owner}/{_preset.Repo}";
// ---------------------------------------------------------------- 清单
/// <summary>
/// 两件事分开取:
/// · **模型清单**永远来自仓库 version.json(模型不需要发 Release)
/// · **启动器版本**只认 Release;没有 Release 时把版本号留空,
/// 由上层去问另一个源(LeaderUpdater 会横向比较)。
/// 以前把两者绑在一起,导致没有 Release 时连模型都同步不了。
/// </summary>
public async Task<RepoVersion?> GetVersionAsync(CancellationToken ct)
{
var fromRepo = await TryGetVersionFromRepoAsync(ct);
var fromRelease = await TryGetVersionFromReleasesAsync(ct);
// 模型清单:仓库里有就用仓库的(保证模型能更新)
var result = fromRepo ?? new RepoVersion
{
Repository = _preset.HomeUrl,
Branch = _preset.Branch
};
if (fromRelease != null)
{
// Release 提供启动器版本与平台附件
result.Launcher.Version = fromRelease.Launcher.Version;
foreach (var kv in fromRelease.Launcher.Packages)
{
// Release 只能说明"哪个附件",完整性必须回到已签名清单取 sha256,
// 否则「有仓库写权限的人发个 Release」就能绕过验签。
if (fromRepo != null &&
fromRepo.Launcher.Packages.TryGetValue(kv.Key, out var signed) &&
!string.IsNullOrWhiteSpace(signed?.Sha256))
{
kv.Value.Sha256 = signed!.Sha256;
if (signed.Size > 0) kv.Value.Size = signed.Size;
}
result.Launcher.Packages[kv.Key] = kv.Value;
}
return result;
}
// 没有 Release:清空启动器版本,让上层知道"这个源没有可升级的启动器"
Console.WriteLine($"[gitea] {_preset.Name}: Release 为空(模型清单仍可用)");
result.Launcher.Version = "";
result.Launcher.Packages.Clear();
// 只有模型清单时也返回,保证模型能同步;启动器版本为空表示无升级
return result.Models.Count > 0 ? result : null;
}
/// <summary>最近一次读到的清单原文(SAVEDOG 二次验签用)。</summary>
public Task<string?> GetRawVersionTextAsync(CancellationToken ct)
=> Task.FromResult(_rawManifest);
/// <summary>读仓库里的 version.json(模型清单 + 兜底信息)。</summary>
private async Task<RepoVersion?> TryGetVersionFromRepoAsync(CancellationToken ct)
{
foreach (var url in new[] { _preset.RawUrl("version.json"), _preset.RawUrl("model/version.json") })
{
try
{
var text = await Http.GetStringAsync(url, ct);
if (!text.TrimStart().StartsWith('{')) continue; // 可能返回 HTML
var doc = ManifestLoader.Parse(text, out var verification);
// 清单验签失败或格式不对时直接返回 null,不再把不可信清单交给上层
if (verification.Trust == ManifestTrust.Invalid)
{
Console.Error.WriteLine($"[gitea] 清单验签失败,已拒绝: {verification.Error}");
return null;
}
if (doc != null)
{
_rawManifest = text;
return doc;
}
}
catch (Exception ex)
{
Console.Error.WriteLine($"[gitea] version.json 读取失败 {url}: {ex.Message}");
}
}
return null;
}
/// <summary>
/// 从 Release 列表里挑**版本号最高**的一个(不是最新发布时间的那个),
/// 并把它对应平台的附件填进 packages。
/// </summary>
private async Task<RepoVersion?> TryGetVersionFromReleasesAsync(CancellationToken ct)
{
try
{
var json = await Http.GetStringAsync($"{RepoApi}/releases", ct);
using var doc = JsonDocument.Parse(json);
if (doc.RootElement.ValueKind != JsonValueKind.Array) return null;
var candidates = new List<(string Version, JsonElement Node)>();
foreach (var rel in doc.RootElement.EnumerateArray())
{
if (rel.TryGetProperty("draft", out var draft) && draft.ValueKind == JsonValueKind.True)
continue; // 草稿不算发布
var tag = rel.TryGetProperty("tag_name", out var t) ? t.GetString() ?? "" : "";
var ver = VersionUtil.Normalize(tag);
if (string.IsNullOrWhiteSpace(ver)) continue;
candidates.Add((ver, rel));
}
if (candidates.Count == 0)
{
// 还没发布 Release 是正常状态:交给上层去问另一个源
Console.WriteLine($"[gitea] {_preset.Name}: Release 列表为空");
return null;
}
var best = candidates
.OrderByDescending(c => VersionUtil.Parse(c.Version))
.First();
var result = new RepoVersion
{
Repository = _preset.HomeUrl,
Branch = _preset.Branch,
Launcher = new RepoLauncher { Version = best.Version }
};
// 附件:按文件名识别平台
if (best.Node.TryGetProperty("assets", out var assets) &&
assets.ValueKind == JsonValueKind.Array)
{
foreach (var a in assets.EnumerateArray())
{
var name = a.TryGetProperty("name", out var n) ? n.GetString() ?? "" : "";
var url = a.TryGetProperty("browser_download_url", out var u) ? u.GetString() ?? "" : "";
if (string.IsNullOrWhiteSpace(name) || string.IsNullOrWhiteSpace(url)) continue;
var rid = PlatformFromAssetName(name);
if (rid == null) continue;
var size = a.TryGetProperty("size", out var s) && s.TryGetInt64(out var sz) ? sz : 0;
result.Launcher.Packages[rid] = new RepoPackage
{
Url = url,
AssetName = name,
Size = size
};
}
}
return result.Launcher.Packages.Count > 0 ? result : null;
}
catch (Exception ex)
{
Console.Error.WriteLine($"[gitea] Release 读取失败({_preset.Name}): {ex.Message}");
return null;
}
}
/// <summary>从附件名推断 RID:GC-1.0.6-win-amd64.zip → win-x64</summary>
private static string? PlatformFromAssetName(string name)
{
var n = name.ToLowerInvariant();
if (!n.EndsWith(".zip")) return null;
if (n.Contains("win") && n.Contains("arm64")) return "win-arm64";
if (n.Contains("win") && (n.Contains("amd64") || n.Contains("x64"))) return "win-x64";
if (n.Contains("mac") && n.Contains("arm64")) return "osx-arm64";
if (n.Contains("mac") && n.Contains("x64")) return "osx-x64";
if (n.Contains("linux") && n.Contains("x64")) return "linux-x64";
return null;
}
// ---------------------------------------------------------------- 目录
public async Task<IReadOnlyList<RepoEntry>> ListTreeAsync(string rootPath, CancellationToken ct)
{
var result = new List<RepoEntry>();
await WalkAsync(rootPath.Trim('/'), "", result, ct, depth: 0);
return result;
}
private async Task WalkAsync(string apiPath, string relPrefix, List<RepoEntry> sink,
CancellationToken ct, int depth)
{
if (depth > 8) return;
var url = $"{RepoRepoContentsUrl()}/{apiPath}";
string json;
try { json = await Http.GetStringAsync(url, ct); }
catch (Exception ex)
{
Console.Error.WriteLine($"[gitea] 列目录失败 {apiPath}: {ex.Message}");
return;
}
using var doc = JsonDocument.Parse(json);
var root = doc.RootElement;
// 单文件
if (root.ValueKind == JsonValueKind.Object)
{
AddFile(root, relPrefix, sink);
return;
}
if (root.ValueKind != JsonValueKind.Array) return;
var subdirs = new List<(string Path, string Rel)>();
foreach (var item in root.EnumerateArray())
{
var type = item.TryGetProperty("type", out var ty) ? ty.GetString() ?? "" : "";
var name = item.TryGetProperty("name", out var nm) ? nm.GetString() ?? "" : "";
if (string.IsNullOrEmpty(name)) continue;
// 跳过构建产物与源码,模型包只需要清单与数据
if (type == "dir")
{
if (IsIgnoredDir(name)) continue;
subdirs.Add((apiPath + "/" + name, relPrefix + name + "/"));
}
else
{
AddFile(item, relPrefix, sink);
}
}
foreach (var (p, rel) in subdirs)
await WalkAsync(p, rel, sink, ct, depth + 1);
}
private string RepoRepoContentsUrl() => $"{RepoApi}/contents";
private static void AddFile(JsonElement item, string relPrefix, List<RepoEntry> sink)
{
var name = item.TryGetProperty("name", out var n) ? n.GetString() ?? "" : "";
var path = item.TryGetProperty("path", out var p) ? p.GetString() ?? "" : name;
var size = item.TryGetProperty("size", out var s) && s.TryGetInt64(out var sz) ? sz : 0;
var dl = item.TryGetProperty("download_url", out var d) ? d.GetString() : null;
var sha = item.TryGetProperty("sha", out var sh) ? sh.GetString() : null;
sink.Add(new RepoEntry
{
Name = name,
Path = path,
RelativePath = relPrefix + name,
IsDirectory = false,
DownloadUrl = dl,
Size = size,
Sha = sha
});
}
private static bool IsIgnoredDir(string name) =>
name is "src" or "bin" or "obj" or "node_modules" or ".git" or ".vs"
or ".idea" or ".vscode";
// ---------------------------------------------------------------- 下载
public async Task<byte[]> DownloadAsync(RepoEntry entry, CancellationToken ct)
{
// 优先用 API 提供的 download_url;没有就按 raw 规约拼
var url = entry.DownloadUrl;
if (string.IsNullOrWhiteSpace(url))
url = _preset.RawUrl(entry.Path);
return await Http.GetByteArrayAsync(url, ct);
}
public async Task<byte[]?> DownloadPackageAsync(RepoPackage package, CancellationToken ct)
{
// 与 GitCode 一致的策略:Release 附件 → 清单路径 → dist/<系统>-<架构>/ 里的编译产物。
// 每个来源都要过 sha256(来自已签名清单),所以多来源不降低安全性。
var candidates = new List<string>();
if (!string.IsNullOrWhiteSpace(package.Url)) candidates.Add(package.Url!.Trim());
foreach (var path in LauncherArtifacts.CandidateFiles(
package.Rid, package.Dir, package.Path, package.Name, ""))
candidates.Add(_preset.RawUrl(path));
foreach (var candidate in candidates)
{
byte[] bytes;
try { bytes = await Http.GetByteArrayAsync(candidate, ct); }
catch (Exception) { continue; }
if (bytes.Length == 0) continue;
if (!string.IsNullOrWhiteSpace(package.Sha256))
{
var actual = Convert.ToHexString(
System.Security.Cryptography.SHA256.HashData(bytes)).ToLowerInvariant();
if (!string.Equals(actual, package.Sha256.Trim(), StringComparison.OrdinalIgnoreCase))
{
Console.Error.WriteLine($"[gitea] 包校验不符,换下一个来源: {candidate}");
continue;
}
}
Console.WriteLine($"[gitea] 启动器包来源: {candidate}");
return bytes;
}
return null;
}
}
-123
View File
@@ -1,123 +0,0 @@
using System;
using System.Collections.Generic;
namespace GC.Services;
/// <summary>
/// 平台标签与「仓库里的编译产物位置」的推导规则。
///
/// 历史背景:启动器更新原本只认 GitCode Release 的附件。但发布者往往只是把编译产物
/// 提交(或上传)到仓库的 <c>dist/&lt;系统&gt;-&lt;架构&gt;</c> 目录,例如
/// <c>dist/mac-arm64/GC-1.0.7-mac-arm64.zip</c>,根本没有发 Release。
/// 于是下载端需要一套「同一个平台有哪几种叫法」的映射,才能把这些目录找出来。
///
/// 安全性说明:多来源尝试**不会**降低安全性——每个候选下载完都要和已签名清单里的
/// sha256 对一遍,对不上就换下一个来源,全都不对就失败。sha256 来自签名清单,
/// 攻击者即使往 dist/ 里塞包也拿不到匹配的哈希。
///
/// 本文件同时被启动器(GC-DOWNLOAD)与构建端(VersionStamp)链接编译,
/// 保证「写进清单的路径」与「运行时找的路径」永远一致。
/// </summary>
public static class LauncherArtifacts
{
/// <summary>
/// RID → 文件名里的「系统-架构」标签(与 <c>LauncherUpdater.PlatformLabel</c> 一致)。
/// </summary>
public static string LabelOf(string rid) => rid switch
{
"win-x64" => "win-amd64",
"win-arm64" => "win-arm64",
"osx-arm64" => "mac-arm64",
"osx-x64" => "mac-x64",
"linux-x64" => "linux-amd64", // 旧产物目录名,仍能读
"linux-arm64" => "linux-arm64",
_ => rid
};
/// <summary>
/// 同一平台在仓库里可能用的目录名(按优先级)。
/// 既接受 <c>mac-arm64</c> 这种标签,也接受 <c>osx-arm64</c> 这种 RID,
/// 因为 dist 目录名历史上两种写法都出现过。
/// </summary>
public static IReadOnlyList<string> PlatformAliases(string rid)
{
var label = LabelOf(rid);
if (string.Equals(label, rid, StringComparison.OrdinalIgnoreCase))
return new[] { rid };
return new[] { label, rid };
}
/// <summary>启动器包应有的文件名,如 <c>GCL-1.0.10-mac-arm64.zip</c>。</summary>
public static string PackageFileName(string version, string rid)
=> $"GCL-{version.Trim().TrimStart('v', 'V')}-{LabelOf(rid)}.zip";
/// <summary>
/// 判断某个 zip 名是不是「这个版本 + 这个平台」的启动器包。
/// 只做粗筛(版本串 + 平台别名),最终仍以 sha256 为准。
/// </summary>
public static bool LooksLikePackage(string fileName, string version, string rid)
{
if (!fileName.EndsWith(".zip", StringComparison.OrdinalIgnoreCase)) return false;
// 1.0.10 起发布包统一叫 GCL-<版本>-<平台>.zip;GC- 是老命名,
// 一并认,装过 1.0.9 及更早版本的机器才不会把新包当成「不是启动器包」。
if (!fileName.StartsWith("GCL-", StringComparison.OrdinalIgnoreCase) &&
!fileName.StartsWith("GC-", StringComparison.OrdinalIgnoreCase)) return false;
var v = version.Trim().TrimStart('v', 'V');
if (v.Length > 0 && fileName.IndexOf(v, StringComparison.OrdinalIgnoreCase) < 0) return false;
var haystack = fileName.ToLowerInvariant();
foreach (var alias in PlatformAliases(rid))
if (haystack.Contains(alias.ToLowerInvariant(), StringComparison.Ordinal))
return true;
return haystack.Contains(rid.ToLowerInvariant(), StringComparison.Ordinal);
}
/// <summary>
/// 候选目录:清单显式给的 dir 优先,其次是 <c>dist/&lt;标签&gt;</c> 与 <c>dist/&lt;RID&gt;</c>。
/// </summary>
public static IReadOnlyList<string> CandidateDirs(string rid, string? declaredDir)
{
var dirs = new List<string>();
if (!string.IsNullOrWhiteSpace(declaredDir))
dirs.Add(declaredDir!.Trim().Trim('/'));
foreach (var alias in PlatformAliases(rid))
dirs.Add("dist/" + alias);
var seen = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
var result = new List<string>();
foreach (var dir in dirs)
if (dir.Length > 0 && seen.Add(dir)) result.Add(dir);
return result;
}
/// <summary>
/// 候选文件路径(不含目录扫描):清单给的 path / name,以及 dist 根目录里的两种命名。
/// </summary>
public static IReadOnlyList<string> CandidateFiles(string rid, string? declaredDir,
string? declaredPath, string? declaredName, string version)
{
var files = new List<string>();
if (!string.IsNullOrWhiteSpace(declaredPath))
files.Add(declaredPath!.Trim().Trim('/'));
if (!string.IsNullOrWhiteSpace(declaredName))
foreach (var dir in CandidateDirs(rid, declaredDir))
files.Add(dir + "/" + declaredName!.Trim());
if (version.Length > 0)
{
files.Add("dist/" + PackageFileName(version, rid));
foreach (var alias in PlatformAliases(rid))
files.Add($"dist/GC-{version.Trim().TrimStart('v', 'V')}-{alias}.zip");
}
var seen = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
var result = new List<string>();
foreach (var file in files)
if (file.Length > 0 && seen.Add(file)) result.Add(file);
return result;
}
}
-807
View File
@@ -1,807 +0,0 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Security.Cryptography;
using System.Threading;
using System.Threading.Tasks;
namespace GC.Services;
// ===========================================================================
// 启动器更新模块(唯一实现)
//
// 需求(按用户):
// · 只认 GitCode Release 的 latest 版本号(tag),文件名格式:
// GC-<版本>-<系统>-<架构>.exe / .app
// 例 GC-1.0.3-win-amd64.exe / GC-1.0.3-mac-arm64.app
// · 当前运行版本与 latest 不同 => 提示更新;相同 => 无需更新
// · 下载的新版解压到「当前运行目录」,与旧版并列;.GC 完全不动
// · 更新完成后:删除同系统同架构、版本号 != latest 的其它 GC-* 文件;
// 异系统 / 异架构的文件一律不碰
// · 一切落盘内容(脚本、标记)只用相对路径,绝不写绝对路径
// ===========================================================================
/// <summary>下载 / 检查 / 应用启动器更新的唯一入口。</summary>
public static class LauncherUpdater
{
/// <summary>当前运行程序的版本号(来自程序集)。</summary>
public static string RunningVersion => LauncherRuntimeInfo.CurrentLauncherVersion;
/// <summary>当前 RID,如 osx-arm64。</summary>
public static string CurrentRid => LauncherRuntimeInfo.CurrentRid;
/// <summary>文件名里用的「系统-架构」标签,如 mac-arm64 / win-amd64。</summary>
public static string PlatformLabel => CurrentRid switch
{
"win-x64" => "win-amd64",
"win-arm64" => "win-arm64",
"osx-arm64" => "mac-arm64",
"osx-x64" => "mac-x64",
"linux-x64" => "linux-amd64",
_ => CurrentRid
};
// ---------------------------------------------------------------- 检查
/// <summary>
/// 检查 Release latest 版本。返回 latest 版本号;若与当前运行版本相同返回 null。
/// 只比版本号,不比 sha256。
/// </summary>
/// <summary>
/// 检查启动器新版本:**两个源(Xhmcl / GitCode)的 Release 都要查**,
/// 取版本号最高的那个作为最新版。任何一个源失败不影响另一个。
/// </summary>
public static async Task<string?> CheckAsync(CancellationToken ct = default)
=> await CheckAllAsync(null, ct);
/// <summary>兼容旧调用:优先用给定 remote,同时仍会比对另一个源。</summary>
public static async Task<string?> CheckAsync(IModelRemote remote, CancellationToken ct = default)
=> await CheckAllAsync(remote, ct);
private static async Task<string?> CheckAllAsync(IModelRemote? preferred, CancellationToken ct)
{
var candidates = new List<(string Source, string Version)>();
foreach (var preset in SourcePreset.All)
{
try
{
// 优先复用调用方已建好的 remote(避免重复建实例)
var remote = preferred != null &&
SourcePreset.Detect(preferred.DisplayName).Id == preset.Id
? preferred
: SourceSelector.CreateRemote(preset);
var version = await remote.GetVersionAsync(ct);
var v = (version?.Launcher.Version ?? "").Trim();
if (v.Length == 0)
{
Console.WriteLine($"[update] {preset.Name}: 没有版本信息(可能还没发 Release)");
continue;
}
Console.WriteLine($"[update] {preset.Name}: {v}");
candidates.Add((preset.Name, v));
}
catch (Exception ex)
{
Console.Error.WriteLine($"[update] {preset.Name} 检查失败: {ex.Message}");
}
}
if (candidates.Count == 0)
{
// 两个源都连不上或都没发 Release:返回一个带明确语义的信号,
// 让上层能区分「检查失败」和「已是最新」。用 null 版本 + 特殊标记表达。
Console.WriteLine("[update] 所有源都不可达,无法检查启动器更新");
return null;
}
// 取版本号最高的(第 7 项)
var best = candidates.OrderByDescending(c => VersionUtil.Parse(c.Version)).First();
Console.WriteLine($"[update] 最新版:{best.Version}(来自 {best.Source})");
var cmp = VersionUtil.Compare(best.Version, RunningVersion);
// 远端版本更新 → 提示更新
if (cmp > 0)
{
Console.WriteLine($"[update] 远端 {best.Version} > 本地 {RunningVersion},提示更新");
return best.Version;
}
// 远端版本更旧 → 不提示
if (cmp < 0)
{
Console.WriteLine($"[update] 远端 {best.Version} < 本地 {RunningVersion},不提示");
return null;
}
// 版本号相同:比对当前程序的 sha256 与 Release 包
// 相符 → 视为最新,不提示
// 不相符 → 说明是重新编译的同版本程序,必须提示下载
var same = await SameFingerprintAsync(best.Source, best.Version, ct);
if (same == null)
{
Console.WriteLine("[update] 版本相同但无法比对 sha256,按最新处理");
return null;
}
if (same.Value)
{
Console.WriteLine("[update] 版本相同且 sha256 一致,已是最新");
return null;
}
// 版本相同但指纹不同:是自行编译的构建,不提示更新
Console.WriteLine("[update] 版本相同但 sha256 不一致,不提示更新");
return null;
}
/// <summary>
/// 比对「当前运行程序」与「Release 平台包」的 sha256。
/// 返回 true=一致(确属同一份构建)、false=不一致(需重新下载)、null=无法比对。
/// </summary>
private static async Task<bool?> SameFingerprintAsync(string sourceName, string version,
CancellationToken ct)
{
try
{
var preset = SourcePreset.All.FirstOrDefault(p =>
string.Equals(p.Name, sourceName, StringComparison.OrdinalIgnoreCase));
if (preset == null) return null;
var rid = CurrentRid;
Console.WriteLine($"[update] 抓取 {preset.Name} 的 {rid} 发布包用于比对…");
// 定位进程对应的可执行文件 / .app
var self = Environment.ProcessPath;
if (string.IsNullOrWhiteSpace(self)) return null;
var selfPath = self!;
// 单文件 / dotnet 宿主时退回到程序集位置
if (Path.GetFileNameWithoutExtension(selfPath).Equals("dotnet", StringComparison.OrdinalIgnoreCase))
selfPath = typeof(LauncherUpdater).Assembly.Location;
var selfHash = await HashFileAsync(selfPath, ct);
Console.WriteLine($"[update] 本地程序 sha256 = {selfHash[..16]}…");
// 下载 Release 对应平台包,取包内主程序再算
var remote = SourceSelector.CreateRemote(preset);
var v = await remote.GetVersionAsync(ct);
if (v == null || !v.Launcher.Packages.TryGetValue(rid, out var pkg) || pkg == null)
return null;
var bytes = await remote.DownloadPackageAsync(pkg, ct);
if (bytes == null || bytes.Length == 0) return null;
var remoteHash = await HashZipPayloadAsync(bytes, ct);
if (remoteHash == null) return null;
Console.WriteLine($"[update] 远端包 sha256 = {remoteHash[..16]}…");
return string.Equals(selfHash, remoteHash, StringComparison.OrdinalIgnoreCase);
}
catch (Exception ex)
{
Console.WriteLine($"[update] sha256 比对失败: {ex.Message}");
return null;
}
}
private static async Task<string> HashFileAsync(string path, CancellationToken ct)
{
await using var fs = File.OpenRead(path);
var hash = await System.Security.Cryptography.SHA256.HashDataAsync(fs, ct);
return Convert.ToHexString(hash);
}
/// <summary>从发布包(zip)里取出主程序并算 sha256。</summary>
private static async Task<string?> HashZipPayloadAsync(byte[] zip, CancellationToken ct)
{
try
{
using var ms = new MemoryStream(zip);
using var archive = new System.IO.Compression.ZipArchive(ms, System.IO.Compression.ZipArchiveMode.Read);
// 发布包从 1.0.10 起改为 GCL 命名 + 单文件 + 单顶层目录,主程序是
// <顶层>/GCL-<版本>-<平台>.exe (Windows)
// <顶层>/GCL-<版本>-<平台> (Linux,无扩展名)
// <顶层>/GCL-<版本>-mac-arm64.app/... (macOS)
// 旧布局则是 GC.dll / GC / GC*.dll。先找新名,再退回旧名,兼容老发布包。
// 注意排除 GC-UI / GC-SAVEDOG / .GC/bin 里的附属程序,它们不是启动器本体。
bool IsLauncher(System.IO.Compression.ZipArchiveEntry e)
{
var n = e.Name;
if (n.Length == 0) return false; // 目录条目
if (n.StartsWith("GC-UI", StringComparison.OrdinalIgnoreCase) ||
n.StartsWith("GC-SAVEDOG", StringComparison.OrdinalIgnoreCase)) return false;
if (e.FullName.Replace('\\', '/').Contains("/.GC/")) return false;
if (n.StartsWith("GCL-", StringComparison.OrdinalIgnoreCase)) return true;
return false;
}
var entry = archive.Entries.FirstOrDefault(IsLauncher)
?? archive.Entries.FirstOrDefault(e =>
e.Name.Equals("GC.dll", StringComparison.OrdinalIgnoreCase))
?? archive.Entries.FirstOrDefault(e =>
e.Name.Equals("GC", StringComparison.OrdinalIgnoreCase))
?? archive.Entries.FirstOrDefault(e =>
e.Name.EndsWith(".dll", StringComparison.OrdinalIgnoreCase) &&
e.Name.StartsWith("GC", StringComparison.OrdinalIgnoreCase));
if (entry == null) return null;
await using var es = entry.Open();
using var buf = new MemoryStream();
await es.CopyToAsync(buf, ct);
var hash = System.Security.Cryptography.SHA256.HashData(buf.ToArray());
return Convert.ToHexString(hash);
}
catch { return null; }
}
/// <summary>
/// 遍历所有源的 Release,取**版本号最高且包含本平台发布包**的那个。
/// 某个源没有 Release(返回 null)时自动跳过。
/// </summary>
private static async Task<(RepoVersion Version, IModelRemote Remote)?> GetBestReleaseAsync(
IModelRemote fallback, CancellationToken ct)
{
var rid = CurrentRid;
var found = new List<(string Source, RepoVersion Version, IModelRemote Remote)>();
foreach (var preset in SourcePreset.All)
{
try
{
var remote = SourceSelector.CreateRemote(preset);
var v = await remote.GetVersionAsync(ct);
if (v == null)
{
Console.WriteLine($"[update] {preset.Name}: 无 Release");
continue;
}
if (string.IsNullOrWhiteSpace(v.Launcher.Version) || v.Launcher.Packages.Count == 0)
{
Console.WriteLine($"[update] {preset.Name}: 没有可用的启动器发布包");
continue;
}
var hasPkg = v.Launcher.Packages.ContainsKey(rid) ||
v.Launcher.Packages.ContainsKey("default");
if (!hasPkg)
{
Console.WriteLine($"[update] {preset.Name}: v{v.Launcher.Version} 缺少 {rid} 发布包");
continue;
}
Console.WriteLine($"[update] {preset.Name}: v{v.Launcher.Version} 可用");
found.Add((preset.Name, v, remote));
}
catch (Exception ex)
{
Console.Error.WriteLine($"[update] {preset.Name} 读取失败: {ex.Message}");
}
}
if (found.Count == 0) return null;
var best = found.OrderByDescending(f => VersionUtil.Parse(f.Version.Launcher.Version)).First();
Console.WriteLine($"[update] 选中最新的可用发布包:v{best.Version.Launcher.Version}({best.Source})");
return (best.Version, best.Remote);
}
// ---------------------------------------------------------------- 下载
/// <summary>
/// 下载 latest 版本到当前运行目录(与旧版并列)。
/// 返回新版包名,供后续替换脚本使用。
/// </summary>
public static async Task<UpdateRunResult> DownloadAsync(
AppPaths paths, IModelRemote remote,
IProgress<UpdateProgressInfo>? progress = null,
CancellationToken ct = default)
{
try
{
progress?.Report(new UpdateProgressInfo { Value = 0.05, Stage = "正在读取最新版本" });
// 两个源都问一遍:某个源没发 Release 时自动换另一个,
// 与「检查更新」保持同一套规则,避免检查通过、下载却报无法读取。
var version = await remote.GetVersionAsync(ct);
// 当前源没有可用的启动器版本(没发 Release / 版本号为空)→ 换另一个源。
// 注意:模型清单可能仍然有效,但启动器升级必须有 Release。
var hasUsable = version != null &&
!string.IsNullOrWhiteSpace(version.Launcher.Version) &&
version.Launcher.Packages.Count > 0;
if (!hasUsable)
{
var tried = SourcePreset.Find(remote.SourceId)?.Name ?? remote.DisplayName;
Console.WriteLine($"[update] {tried} 没有可用的启动器发布包,换另一个源");
var pick = await GetBestReleaseAsync(remote, ct);
if (pick == null) return Fail("两个源都没有可用的 Release 发布包");
version = pick.Value.Version;
remote = pick.Value.Remote; // 后续下载必须用这个源的 remote
}
var latest = (version!.Launcher.Version ?? "").Trim();
var rid = CurrentRid;
if (!version.Launcher.Packages.TryGetValue(rid, out var pkg) &&
!version.Launcher.Packages.TryGetValue("default", out pkg))
return Fail($"该平台({rid})没有对应发布包");
// ---- 信任闸门 ---------------------------------------------------
// 启动器更新会替换可执行文件,风险最高:清单没签名就一律不动。
// 只有显式设置 GC_ALLOW_UNSIGNED_MANIFEST=1(自建私有构建)才放行。
var allowUnsigned =
Environment.GetEnvironmentVariable("GC_ALLOW_UNSIGNED_MANIFEST") == "1";
if (!version.IsTrusted && !allowUnsigned)
{
var reason = version.SignatureTrust == nameof(ManifestTrust.Invalid)
? "清单签名无效"
: "清单未签名";
Console.Error.WriteLine($"[update] 启动器更新被拒绝:{reason}");
return Fail($"{reason},已拒绝下载启动器更新");
}
if (string.IsNullOrWhiteSpace(pkg!.Sha256))
{
Console.Error.WriteLine("[update] 清单没有提供 sha256,拒绝下载启动器更新");
return Fail("清单缺少该平台的 sha256,已拒绝下载(无法校验完整性)");
}
progress?.Report(new UpdateProgressInfo { Value = 0.20, Stage = $"正在下载 v{latest}" });
var bytes = await remote.DownloadPackageAsync(pkg!, ct);
if (bytes == null || bytes.Length == 0) return Fail("下载失败:发布包为空");
// sha256 校验(清单已验签,这里的 sha256 就是"正版"的定义)
{
var actual = Convert.ToHexString(SHA256.HashData(bytes)).ToLowerInvariant();
if (!string.Equals(actual, pkg.Sha256!.Trim(), StringComparison.OrdinalIgnoreCase))
return Fail("下载文件校验失败(sha256 与已签名清单不符)");
}
progress?.Report(new UpdateProgressInfo { Value = 0.55, Stage = "正在校验更新包" });
var updateRoot = paths.UpdateRoot;
Directory.CreateDirectory(updateRoot);
// 更新包留在 .GC/update,交给 SAVEDOG 自己解压 —— 不信任"预解压目录",
// 避免「解压后被替换」的中间窗口。
var zip = Path.Combine(updateRoot, "package.zip");
if (File.Exists(zip)) File.Delete(zip);
await File.WriteAllBytesAsync(zip, bytes, ct);
try
{
var inspection = SafeArchive.Inspect(zip);
Console.WriteLine($"[update] 更新包检查通过:{inspection.Entries} 个条目," +
$"{inspection.UncompressedBytes / 1024 / 1024} MB");
}
catch (Exception ex)
{
try { File.Delete(zip); } catch { }
return Fail("更新包安全性检查失败: " + ex.Message);
}
// 二次验签用的清单副本:SAVEDOG 不信任"启动器说它验过了"
var rawManifest = await remote.GetRawVersionTextAsync(ct);
var manifestCopy = Path.Combine(updateRoot, "version.json");
if (!string.IsNullOrWhiteSpace(rawManifest))
File.WriteAllText(manifestCopy, rawManifest!);
else if (File.Exists(manifestCopy))
File.Delete(manifestCopy);
// 包名:GCL-<版本>-<平台标签>.app/.exe(SAVEDOG 找不到时会自行扫描包内顶层)。
// Linux 的启动器没有扩展名,别硬加 .exe —— 那会让按包名查找永远落空。
var packageName = $"GCL-{latest}-{PlatformLabel}" +
(OperatingSystem.IsMacOS() ? ".app"
: OperatingSystem.IsWindows() ? ".exe"
: "");
var request = new SavedogRequest
{
Version = latest,
Rid = rid,
PlatformLabel = PlatformLabel,
PackageName = packageName,
PackageZip = "package.zip",
PayloadDir = "payload",
ManifestPath = "version.json",
PackageSha256 = pkg.Sha256!.Trim().ToLowerInvariant(),
PackageSize = bytes.LongLength,
RequireSignature = version.IsTrusted,
InstallRelative = Path.GetRelativePath(updateRoot, paths.InstallDirectory),
CreatedAt = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ssZ")
};
Json.Write(Path.Combine(updateRoot, SavedogFiles.ApplyRequest), request);
// 兼容兜底:没有 SAVEDOG 的旧安装,仍然按老方式预解压 + 脚本替换
string? legacyPath = null;
if (SavedogLauncher.Find(paths) == null)
{
Console.WriteLine("[update] 未找到 GC-SAVEDOG,使用兼容脚本流程");
progress?.Report(new UpdateProgressInfo { Value = 0.7, Stage = "正在解压更新包" });
var staging = Path.Combine(paths.CacheRoot, "launcher-staging");
if (Directory.Exists(staging)) Directory.Delete(staging, true);
Directory.CreateDirectory(staging);
SafeArchive.ExtractToDirectory(zip, staging);
FlattenStaging(staging);
var payload = Path.Combine(updateRoot, "payload");
if (Directory.Exists(payload)) Directory.Delete(payload, true);
Directory.CreateDirectory(payload);
var legacyName = MoveToPayload(staging, payload);
try { Directory.Delete(staging, true); } catch { }
if (legacyName == null) return Fail("解压结果里没有找到新版启动器");
packageName = legacyName;
request.PackageName = legacyName;
Json.Write(Path.Combine(updateRoot, SavedogFiles.ApplyRequest), request);
legacyPath = Path.Combine(payload, legacyName);
// 老脚本读这个纯文本标记,只含相对信息
File.WriteAllText(Path.Combine(updateRoot, "update.txt"),
$"NAME={legacyName}\nVERSION={latest}\nPLATFORM={PlatformLabel}\n" +
$"INSTALL_REL={request.InstallRelative}\n");
}
progress?.Report(new UpdateProgressInfo { Value = 1.0, Stage = "下载完成" });
return new UpdateRunResult
{
State = UpdateRunState.Ready,
Version = latest,
Message = $"v{latest} 已暂存到 .GC/update",
PackageName = packageName,
NewAppPath = legacyPath
};
}
catch (OperationCanceledException) { return Fail("已取消"); }
catch (Exception ex) { return Fail(ex.Message); }
}
private static UpdateRunResult Fail(string msg) => new()
{
State = UpdateRunState.Failed,
Message = msg
};
// ---------------------------------------------------------------- 应用(下次启动)
/// <summary>
/// 安排应用已下载的新版。
/// 首选 <b>GC-SAVEDOG</b>:二次验签、原子替换、启动后健康检查、失败自动回滚;
/// 找不到 SAVEDOG 时退回旧脚本流程(只用于从老版本升级的过渡)。
/// 返回 true 表示调用方应立即退出进程。
/// </summary>
/// <param name="execute">只写脚本不执行(测试用,避免真的搬动文件)。</param>
public static bool ScheduleApply(AppPaths paths, string packageName, bool execute = true)
{
// 安全阀:绝不在源码目录执行替换(防止误删源码)
if (File.Exists(Path.Combine(paths.InstallDirectory, "GC.sln")))
{
Console.Error.WriteLine("源码版:新版已下载,但拒绝在源码目录执行替换");
return false;
}
if (File.Exists(Path.Combine(paths.UpdateRoot, SavedogFiles.ApplyRequest)))
{
string? savedogError = null;
if (SavedogLauncher.TryStart(paths, Environment.ProcessId, out savedogError))
return true;
Console.Error.WriteLine($"[update] {savedogError},改用兼容脚本");
}
var marker = Path.Combine(paths.UpdateRoot, "update.txt");
if (!File.Exists(marker)) return false;
try
{
var isWin = OperatingSystem.IsWindows();
var script = Path.Combine(paths.UpdateRoot, isWin ? "apply.bat" : "apply.sh");
var content = isWin ? WindowsScript() : UnixScript();
File.WriteAllText(script, content, new System.Text.UTF8Encoding(false));
if (!isWin)
{
try
{
File.SetUnixFileMode(script,
UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute);
}
catch { }
}
if (!execute) return true;
var psi = isWin
? new System.Diagnostics.ProcessStartInfo("cmd.exe")
{ UseShellExecute = false, CreateNoWindow = true }
: new System.Diagnostics.ProcessStartInfo("/bin/sh")
{ UseShellExecute = false, CreateNoWindow = true };
if (isWin) psi.ArgumentList.Add("/c");
psi.ArgumentList.Add(script);
System.Diagnostics.Process.Start(psi);
return true;
}
catch (Exception ex)
{
Console.Error.WriteLine($"启动替换脚本失败: {ex.Message}");
return false;
}
}
/// <summary>启动时若有待应用更新:交给 SAVEDOG,由调用方退出进程。</summary>
public static bool TryApplyPending(AppPaths paths)
{
if (paths.IsDevelopment) return false;
if (Environment.GetEnvironmentVariable("EMS_SELFTEST") == "1") return false;
if (Environment.GetEnvironmentVariable("EMS_NO_SELF_UPDATE") == "1") return false;
// 新协议:apply-request.json + package.zip(SAVEDOG 自己解压 + 验签)
var requestPath = Path.Combine(paths.UpdateRoot, SavedogFiles.ApplyRequest);
if (File.Exists(requestPath))
{
var request = Json.Read<SavedogRequest>(requestPath);
var zipPath = request == null
? null
: Path.Combine(paths.UpdateRoot, request.PackageZip);
if (request != null && zipPath != null && File.Exists(zipPath))
return ScheduleApply(paths, request.PackageName);
Console.Error.WriteLine("[update] 更新申请不完整,已清理");
try { File.Delete(requestPath); } catch { }
}
// 旧协议:update.txt + payload(从老版本升级时仍可能遇到)
var marker = Path.Combine(paths.UpdateRoot, "update.txt");
if (!File.Exists(marker)) return false;
var name = ReadMarker(marker, "NAME");
if (string.IsNullOrWhiteSpace(name)) return false;
var payloadPath = Path.Combine(paths.UpdateRoot, "payload", name!);
if (!File.Exists(payloadPath) && !Directory.Exists(payloadPath))
return false; // 新版本不在了,放弃
return ScheduleApply(paths, name!);
}
// ---------------------------------------------------------------- 脚本(全部相对路径)
private static string UnixScript()
{
var s = new System.Text.StringBuilder();
s.AppendLine("#!/bin/sh");
s.AppendLine("# script lives in .GC/update/ ; install path is recorded relatively");
s.AppendLine("HERE=$(CDPATH= cd -- \"$(dirname -- \"$0\")\" && pwd)");
s.AppendLine("MARKER=\"$HERE/update.txt\"");
s.AppendLine();
s.AppendLine("# read marker");
s.AppendLine("NEWNAME=$(sed -n 's/^NAME=//p' \"$MARKER\" 2>/dev/null | head -1)");
s.AppendLine("NEWVER=$(sed -n 's/^VERSION=//p' \"$MARKER\" 2>/dev/null | head -1)");
s.AppendLine("NEWPLAT=$(sed -n 's/^PLATFORM=//p' \"$MARKER\" 2>/dev/null | head -1)");
s.AppendLine("INSTALLREL=$(sed -n 's/^INSTALL_REL=//p' \"$MARKER\" 2>/dev/null | head -1)");
s.AppendLine("if [ -z \"$NEWNAME\" ] || [ -z \"$NEWVER\" ] || [ -z \"$INSTALLREL\" ]; then");
s.AppendLine(" echo \"marker incomplete, abort\"; rm -f \"$HERE\"/*.sh 2>/dev/null; exit 1");
s.AppendLine("fi");
s.AppendLine("DST=$(CDPATH= cd -- \"$HERE/$INSTALLREL\" && pwd)");
s.AppendLine("PAYLOAD=\"$HERE/payload/$NEWNAME\"");
s.AppendLine("if [ ! -e \"$PAYLOAD\" ]; then");
s.AppendLine(" echo \"new package missing, abort\"; rm -f \"$HERE\"/*.sh 2>/dev/null; exit 1");
s.AppendLine("fi");
s.AppendLine();
s.AppendLine("# wait for old process to exit (this script is started by it)");
s.AppendLine("sleep 2");
s.AppendLine();
s.AppendLine("# move the staged package into the install directory");
s.AppendLine("NEW=\"$DST/$NEWNAME\"");
s.AppendLine("rm -rf \"$NEW\"");
s.AppendLine("mv \"$PAYLOAD\" \"$NEW\"");
s.AppendLine();
s.AppendLine("# launch new version");
s.AppendLine("if [ -d \"$NEW\" ]; then open \"$NEW\" 2>/dev/null &");
s.AppendLine("elif [ -x \"$NEW\" ]; then \"$NEW\" >/dev/null 2>&1 &");
s.AppendLine("fi");
s.AppendLine();
s.AppendLine("# delete old GC-* files: SAME platform only, version != latest");
s.AppendLine("# files of OTHER platforms are NEVER touched");
// Linux 的启动器没有扩展名(GC-1.0.9-linux-amd64),只匹配 *.app/*.exe 会漏掉,
// 结果是每次更新都在安装目录里多留一个旧版本。这里统一按 GC- 前缀扫,
// 再用「版本号-平台」的形态兜底,避免误删同目录的其它文件。
s.AppendLine("for item in \"$DST\"/GC-*; do");
s.AppendLine(" [ -e \"$item\" ] || continue");
s.AppendLine(" [ \"$item\" = \"$NEW\" ] && continue");
s.AppendLine(" base=$(basename \"$item\")");
s.AppendLine(" stem=${base#GC-}");
s.AppendLine(" case \"$base\" in");
s.AppendLine(" *.app) stem=${stem%.app} ;;");
s.AppendLine(" *.exe) stem=${stem%.exe} ;;");
s.AppendLine(" esac");
s.AppendLine(" # 只认 <版本>-<系统>-<架构>,其它名字一律不动");
s.AppendLine(" case \"$stem\" in");
s.AppendLine(" [0-9]*-*-*) ;;");
s.AppendLine(" *) continue ;;");
s.AppendLine(" esac");
s.AppendLine(" ver=${stem%%-*}");
s.AppendLine(" rest=${stem#*-}");
s.AppendLine(" plat=\"${rest%-*}-${rest##*-}\"");
s.AppendLine(" # skip other platforms entirely");
s.AppendLine(" [ \"$plat\" != \"$NEWPLAT\" ] && continue");
s.AppendLine(" # same platform: keep only latest version");
s.AppendLine(" if [ \"$ver\" = \"$NEWVER\" ]; then");
s.AppendLine(" echo \"keep: $base\"");
s.AppendLine(" else");
s.AppendLine(" echo \"remove (version $ver != $NEWVER): $base\"");
s.AppendLine(" rm -rf \"$item\" 2>/dev/null");
s.AppendLine(" fi");
s.AppendLine("done");
s.AppendLine();
s.AppendLine("rm -f \"$MARKER\"");
s.AppendLine("rm -f \"$HERE\"/*.sh 2>/dev/null");
return s.ToString();
}
private static string WindowsScript()
{
var s = new System.Text.StringBuilder();
s.AppendLine("@echo off");
s.AppendLine("chcp 65001 >nul 2>&1");
s.AppendLine("set \"HERE=%~dp0\"");
s.AppendLine("set \"MARKER=%~dp0update.txt\"");
s.AppendLine("timeout /t 2 /nobreak >nul");
s.AppendLine();
s.AppendLine("set \"NEWNAME=\"");
s.AppendLine("set \"NEWVER=\"");
s.AppendLine("set \"NEWPLAT=\"");
s.AppendLine("set \"INSTALLREL=\"");
s.AppendLine("for /f \"tokens=2 delims==\" %%A in ('findstr /b \"NAME=\" \"%MARKER%\" 2^>nul') do set \"NEWNAME=%%A\"");
s.AppendLine("for /f \"tokens=2 delims==\" %%A in ('findstr /b \"VERSION=\" \"%MARKER%\" 2^>nul') do set \"NEWVER=%%A\"");
s.AppendLine("for /f \"tokens=2 delims==\" %%A in ('findstr /b \"PLATFORM=\" \"%MARKER%\" 2^>nul') do set \"NEWPLAT=%%A\"");
s.AppendLine("for /f \"tokens=2 delims==\" %%A in ('findstr /b \"INSTALL_REL=\" \"%MARKER%\" 2^>nul') do set \"INSTALLREL=%%A\"");
s.AppendLine("if \"%NEWNAME%\"==\"\" (echo marker incomplete, abort & del /Q \"%~f0\" >nul 2>&1 & exit /b 1)");
s.AppendLine("if \"%INSTALLREL%\"==\"\" (echo install path missing, abort & del /Q \"%~f0\" >nul 2>&1 & exit /b 1)");
s.AppendLine("for %%I in (\"%HERE%%INSTALLREL%\") do set \"DST=%%~fI\"");
s.AppendLine("set \"PAYLOAD=%HERE%payload\\%NEWNAME%\"");
s.AppendLine("if not exist \"%PAYLOAD%\" (echo new package missing, abort & del /Q \"%~f0\" >nul 2>&1 & exit /b 1)");
s.AppendLine();
s.AppendLine("rem move the staged package into the install directory");
s.AppendLine("if exist \"%DST%\\%NEWNAME%\" rmdir /S /Q \"%DST%\\%NEWNAME%\" 2>nul");
s.AppendLine("if exist \"%DST%\\%NEWNAME%\" del /Q \"%DST%\\%NEWNAME%\" 2>nul");
s.AppendLine("move \"%PAYLOAD%\" \"%DST%\\%NEWNAME%\" >nul");
s.AppendLine("if errorlevel 1 (echo failed to install update & exit /b 1)");
s.AppendLine();
s.AppendLine("rem launch new version");
s.AppendLine("start \"\" \"%DST%\\%NEWNAME%\"");
s.AppendLine();
s.AppendLine("rem delete old GC-* files: SAME platform only, version != latest");
s.AppendLine("powershell -NoProfile -ExecutionPolicy Bypass -Command \"^");
s.AppendLine("$dst='%DST%'; $new='%NEWNAME%'; $ver='%NEWVER%'; $plat='%NEWPLAT%';^");
s.AppendLine("Get-ChildItem -LiteralPath $dst -Filter 'GC-*' | ForEach-Object {^");
s.AppendLine(" $n=$_.Name; if($n -eq $new){return};^");
s.AppendLine(" $m=[regex]::Match($n,'^GC-(.+?)-([^-]+)-([^-]+)\\.(app|exe)$');^");
s.AppendLine(" if(-not $m.Success){return};^");
s.AppendLine(" $fver=$m.Groups[1].Value; $fplat=$m.Groups[2].Value+'-'+$m.Groups[3].Value;^");
s.AppendLine(" if($fplat -ne $plat){return};^");
s.AppendLine(" if($fver -eq $ver){ Write-Host \\\"keep: $n\\\" }^");
s.AppendLine(" else { Write-Host \\\"remove: $n\\\"; Remove-Item -LiteralPath $_.FullName -Recurse -Force -ErrorAction SilentlyContinue }^");
s.AppendLine("}\"");
s.AppendLine();
s.AppendLine("del /Q \"%MARKER%\" >nul 2>&1");
s.AppendLine("del /Q \"%~f0\" >nul 2>&1");
return s.ToString();
}
// ---------------------------------------------------------------- 内部工具
/// <summary>展平只有一个顶层目录、且不是 .app 的 zip。</summary>
private static void FlattenStaging(string dir)
{
var entries = Directory.GetFileSystemEntries(dir);
if (entries.Length != 1 || !Directory.Exists(entries[0])) return;
var inner = entries[0];
if (Path.GetFileName(inner).EndsWith(".app", StringComparison.OrdinalIgnoreCase)) return;
var flat = dir + "-flat";
if (Directory.Exists(flat)) Directory.Delete(flat, true);
Directory.Move(inner, flat);
Directory.Delete(dir, true);
Directory.Move(flat, dir);
}
/// <summary>
/// 把 staging 里的新版搬入下载目录的 payload。
/// 返回新版包名(GC-&lt;版本&gt;-&lt;平台&gt;.app/.exe)。
/// </summary>
private static string? MoveToPayload(string staging, string payload)
{
try
{
foreach (var entry in Directory.GetFileSystemEntries(staging))
{
var name = Path.GetFileName(entry);
if (string.Equals(name, ".GC", StringComparison.OrdinalIgnoreCase)) continue;
var dest = Path.Combine(payload, name);
if (Directory.Exists(dest)) Directory.Delete(dest, true);
else if (File.Exists(dest)) File.Delete(dest);
if (Directory.Exists(entry)) Directory.Move(entry, dest);
else File.Move(entry, dest);
// 保证 .app 里可执行文件可执行
if (name.EndsWith(".app", StringComparison.OrdinalIgnoreCase) && Directory.Exists(dest))
{
var macOs = Path.Combine(dest, "Contents", "MacOS");
if (Directory.Exists(macOs))
{
try
{
foreach (var f in Directory.GetFiles(macOs, "*", SearchOption.TopDirectoryOnly))
{
var mode = File.GetUnixFileMode(f);
File.SetUnixFileMode(f, mode | UnixFileMode.UserExecute);
}
}
catch { }
}
return name;
}
if (name.EndsWith(".exe", StringComparison.OrdinalIgnoreCase)) return name;
// Linux 的启动器没有扩展名(GC-1.0.9-linux-amd64),以前只认 .app/.exe,
// 结果解压完判定「没找到新版启动器」,Linux 更新永远失败。
// 注意不能用 Path.HasExtension:版本号 9.9.9 里的点会让它误判成有扩展名。
if ((name.StartsWith("GC-", StringComparison.OrdinalIgnoreCase) ||
name.StartsWith("GCL-", StringComparison.OrdinalIgnoreCase)) &&
name.EndsWith("-" + PlatformLabel, StringComparison.OrdinalIgnoreCase))
{
TryMarkExecutable(dest);
return name;
}
}
}
catch (Exception ex)
{
Console.Error.WriteLine($"安装新版失败: {ex.Message}");
}
return null;
}
/// <summary>给 Linux/macOS 上的可执行文件补上执行位(zip 不保留权限)。</summary>
private static void TryMarkExecutable(string path)
{
if (OperatingSystem.IsWindows() || !File.Exists(path)) return;
try
{
var mode = File.GetUnixFileMode(path);
File.SetUnixFileMode(path, mode | UnixFileMode.UserExecute |
UnixFileMode.GroupExecute | UnixFileMode.OtherExecute);
}
catch
{
// 权限设置失败不影响后续流程,用户可手动 chmod
}
}
private static string? ReadMarker(string file, string key)
{
try
{
foreach (var line in File.ReadAllLines(file))
{
if (line.StartsWith(key + "=", StringComparison.Ordinal))
return line[(key.Length + 1)..].Trim();
}
}
catch { }
return null;
}
private static string Safe(string value)
{
foreach (var c in Path.GetInvalidFileNameChars()) value = value.Replace(c, '-');
return value.Replace('/', '-').Replace(' ', '-');
}
}
-142
View File
@@ -1,142 +0,0 @@
using System;
using System.IO;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using GC.Models;
namespace GC.Services;
public static class ModelInstaller
{
// 与后端 /api/models/{id} 的白名单保持一致:单段名称,首字符必须字母或数字。
// 拒绝 . / .. / 路径分隔符 / 盘符 / 绝对路径,杜绝把 model.Id 当成路径来用。
private static readonly Regex SafeId = new(
"^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$", RegexOptions.Compiled);
/// <summary>把源里的模型目录复制进本地模型库(先写临时目录再原子替换)。</summary>
public static async Task<string> InstallAsync(RemoteModel model, string modelRoot,
IProgress<(long Done, long Total)>? progress, CancellationToken ct)
{
ArgumentNullException.ThrowIfNull(model);
if (string.IsNullOrWhiteSpace(modelRoot))
throw new InvalidOperationException("模型根目录未配置");
// ---- 1. 模型标识必须是单段安全名称,且解析后仍在模型根目录内 ----
var target = SafeChildPath(modelRoot, model.Id);
var rootFull = Path.GetFullPath(modelRoot);
var staging = VerifyUnderRoot(target + ".installing", rootFull);
var backup = VerifyUnderRoot(target + ".old", rootFull);
// ---- 2. 源目录与三个目标路径都不能是符号链接/重解析点 ----
EnsureNoLink(model.Directory);
foreach (var p in new[] { target, staging, backup }) EnsureNoLink(p);
if (Directory.Exists(staging)) Directory.Delete(staging, true);
Directory.CreateDirectory(staging);
// 枚举时跳过符号链接/重解析点:源目录里若有人放了指向外部的链接,
// 绝不能顺着它把模型库外的文件读进来。
var enumeration = new EnumerationOptions
{
RecurseSubdirectories = true,
AttributesToSkip = FileAttributes.ReparsePoint,
IgnoreInaccessible = false
};
var files = Directory.GetFiles(model.Directory, "*", enumeration);
long total = 0;
foreach (var file in files)
{
try { total += new FileInfo(file).Length; } catch { }
}
long done = 0;
try
{
foreach (var file in files)
{
ct.ThrowIfCancellationRequested();
var relative = Path.GetRelativePath(model.Directory, file);
// 路径穿越防护:相对路径必须完整落在 staging 目录内
var dest = VerifyUnderRoot(Path.Combine(staging, relative), Path.GetFullPath(staging));
var destDir = Path.GetDirectoryName(dest);
if (!string.IsNullOrEmpty(destDir)) Directory.CreateDirectory(destDir);
await using (var src = File.OpenRead(file))
await using (var dst = File.Create(dest))
{
await src.CopyToAsync(dst, 81920, ct);
}
long length = 0;
try { length = new FileInfo(dest).Length; } catch { }
done += length;
progress?.Report((done, total <= 0 ? done : total));
}
// 原子替换:先备份旧目录,第二次 Move 失败时完整回滚,绝不把模型库清空
if (Directory.Exists(backup)) Directory.Delete(backup, true);
var hasBackup = false;
try
{
if (Directory.Exists(target))
{
Directory.Move(target, backup);
hasBackup = true;
}
Directory.Move(staging, target);
}
catch
{
// 新目录尚未就位时把旧目录还原;staging 由外层 catch 清理
if (hasBackup && !Directory.Exists(target) && Directory.Exists(backup))
Directory.Move(backup, target);
throw;
}
if (hasBackup)
{
try { Directory.Delete(backup, true); } catch { /* 占用时留到下次 */ }
}
progress?.Report((total, total));
return target;
}
catch
{
try { if (Directory.Exists(staging)) Directory.Delete(staging, true); } catch { }
throw;
}
}
/// <summary>把 id 限定为单段安全名称,并确认拼出来的路径仍在 root 内。</summary>
private static string SafeChildPath(string root, string? id)
{
if (string.IsNullOrWhiteSpace(id) ||
id == "." || id == ".." ||
id.IndexOfAny(new[] { '/', '\\', ':' }) >= 0 ||
Path.IsPathRooted(id) ||
!SafeId.IsMatch(id))
throw new InvalidOperationException($"非法的模型标识: {id}");
var rootFull = Path.GetFullPath(root);
return VerifyUnderRoot(Path.Combine(rootFull, id), rootFull);
}
/// <summary>解析绝对路径并确认 candidate 位于 root 之内。</summary>
private static string VerifyUnderRoot(string candidate, string rootFull)
{
var full = Path.GetFullPath(candidate);
var prefix = rootFull.TrimEnd(Path.DirectorySeparatorChar) + Path.DirectorySeparatorChar;
if (!full.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
throw new InvalidOperationException($"路径越界: {candidate}");
return full;
}
/// <summary>拒绝符号链接 / junction / 重解析点,避免顺着链接写到模型库外。</summary>
private static void EnsureNoLink(string path)
{
if (!File.Exists(path) && !Directory.Exists(path)) return;
if ((File.GetAttributes(path) & FileAttributes.ReparsePoint) != 0)
throw new InvalidOperationException($"拒绝符号链接路径: {path}");
}
}
-100
View File
@@ -1,100 +0,0 @@
using System;
using System.IO;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;
namespace GC.Services;
/// <summary>
/// 带断点续传的流式下载器。已下载的部分写在 <c>*.part</c> 文件里,
/// 完整下载后由调用方把 .part 改成正式文件名。
///
/// 为什么需要它:模型源码 zip 可能有上百 MB,弱网中断后如果每次都从头下,
/// 用户会反复卡在同一个地方。这里用 HTTP Range 从已下载的字节接着下。
///
/// 兼容性:服务器不支持 Range(忽略请求、返回 200)时自动退化为整段下载,
/// 不会卡死或拿到半截文件。<see cref="Content-Range"/> 起始位置不符时也从头下。
///
/// .part 文件只有在"续传"场景才复用;一旦下载完整、调用方改名为正式文件,
/// 下次就是全新下载,不会把旧内容接在新内容后面。
/// </summary>
public static class ResumableDownloader
{
/// <summary>
/// 下载 <paramref name="url"/>,数据写入 <paramref name="partPath"/>。
/// 返回最终 .part 文件的字节数。下载完整后由调用方负责改名 / 校验。
/// </summary>
public static async Task<long> DownloadAsync(
HttpClient http,
string url,
string partPath,
IProgress<(long Done, long Total)>? progress,
CancellationToken ct)
{
// 已有 .part 就尝试从断点续传;没有则从头下
long resumeFrom = 0;
if (File.Exists(partPath))
{
try { resumeFrom = new FileInfo(partPath).Length; }
catch { resumeFrom = 0; }
}
using var req = new HttpRequestMessage(HttpMethod.Get, url);
if (resumeFrom > 0)
req.Headers.Range = new RangeHeaderValue(resumeFrom, null);
using var response = await http.SendAsync(req, HttpCompletionOption.ResponseHeadersRead, ct)
.ConfigureAwait(false);
response.EnsureSuccessStatusCode();
var canResume = response.StatusCode == HttpStatusCode.PartialContent && resumeFrom > 0;
long? total = response.Content.Headers.ContentLength;
if (canResume)
{
// 校验服务器确实从我们要的位置开始返回:Content-Range: bytes START-END/TOTAL
var range = response.Content.Headers.ContentRange;
if (range?.HasRange == true && range.From == resumeFrom && range.Length.HasValue)
{
total = range.Length.Value;
}
else
{
// 服务器忽略了 Range 或给出的范围对不上:从头覆盖,避免拼接出损坏的文件
canResume = false;
resumeFrom = 0;
}
}
var mode = canResume ? FileMode.Append : FileMode.Create;
var dir = Path.GetDirectoryName(partPath);
if (!string.IsNullOrEmpty(dir)) Directory.CreateDirectory(dir);
await using (var input = await response.Content.ReadAsStreamAsync(ct).ConfigureAwait(false))
await using (var output = new FileStream(partPath, mode, FileAccess.Write, FileShare.Read,
81920, useAsync: true))
{
var buffer = new byte[81920];
long done = resumeFrom;
int read;
while ((read = await input.ReadAsync(buffer.AsMemory(), ct).ConfigureAwait(false)) > 0)
{
await output.WriteAsync(buffer.AsMemory(0, read), ct).ConfigureAwait(false);
done += read;
// Total 未知时用已下载量当分母,进度条会停在 100% 之前但不报错
progress?.Report((done, total ?? done));
}
}
return SafeLength(partPath);
}
private static long SafeLength(string path)
{
try { return new FileInfo(path).Length; }
catch { return 0; }
}
}
-138
View File
@@ -1,138 +0,0 @@
using System;
using System.Diagnostics;
using System.IO;
using System.Linq;
namespace GC.Services;
/// <summary>
/// 找到并启动 GC-SAVEDOG(启动器更新的守护进程)。
///
/// 为什么要独立进程:启动器正在运行时无法安全覆盖自己;一旦覆盖失败,
/// 启动器已退出,就没人能回滚。把"替换 + 看护"交给一个只做这件事的小程序,
/// 风险面被压缩到最小,也便于审计。
/// </summary>
public static class SavedogLauncher
{
/// <summary>在安装目录里寻找 SAVEDOG 可执行文件。</summary>
public static string? Find(AppPaths paths)
{
var name = SavedogFiles.ExecutableName;
var install = paths.InstallDirectory;
// 首选 .GC/safedog:更新时整目录替换不会碰这里,正在运行的守护进程也安全。
var home = Path.Combine(paths.SafedogRoot, name);
if (File.Exists(home)) return home;
// 包内 payload:非本体文件统一收在 .GC/bin
var payload = Path.Combine(install, ".GC", "bin", name);
if (File.Exists(payload)) return payload;
var direct = Path.Combine(install, name);
if (File.Exists(direct)) return direct;
// 1.0.10 及更早的包把守护进程放在 safedog/ 子目录
var packaged = Path.Combine(install, "safedog", name);
if (File.Exists(packaged)) return packaged;
// macOS:可能放在 .app 内部
try
{
foreach (var app in Directory.GetDirectories(install, "*.app"))
{
var inside = Path.Combine(app, "Contents", "MacOS", name);
if (File.Exists(inside)) return inside;
}
}
catch { }
var bin = Path.Combine(paths.HomeRoot, "bin", name);
if (File.Exists(bin)) return bin;
try
{
var exe = Environment.ProcessPath;
if (!string.IsNullOrWhiteSpace(exe))
{
var beside = Path.Combine(Path.GetDirectoryName(exe)!, name);
if (File.Exists(beside)) return beside;
}
}
catch { }
return null;
}
/// <summary>
/// 启动 SAVEDOG 应用更新。<paramref name="waitForPid"/> 是当前启动器进程,
/// SAVEDOG 会等它退出后再动文件。
/// </summary>
public static bool TryStart(AppPaths paths, int waitForPid, out string? error)
{
error = null;
var exe = Find(paths);
if (exe == null)
{
error = "未找到 GC-SAVEDOG";
return false;
}
try
{
var requestPath = Path.Combine(paths.UpdateRoot, SavedogFiles.ApplyRequest);
if (!File.Exists(requestPath))
{
error = "缺少 apply-request.json";
return false;
}
var psi = new ProcessStartInfo(exe)
{
UseShellExecute = false,
CreateNoWindow = true,
WorkingDirectory = paths.InstallDirectory
};
psi.ArgumentList.Add("apply");
psi.ArgumentList.Add("--update");
psi.ArgumentList.Add(paths.UpdateRoot);
psi.ArgumentList.Add("--install");
psi.ArgumentList.Add(paths.InstallDirectory);
psi.ArgumentList.Add("--wait-pid");
psi.ArgumentList.Add(waitForPid.ToString());
psi.ArgumentList.Add("--timeout");
psi.ArgumentList.Add("45");
if (!OperatingSystem.IsWindows())
{
try
{
var mode = File.GetUnixFileMode(exe);
File.SetUnixFileMode(exe, mode | UnixFileMode.UserExecute);
}
catch { }
}
var process = Process.Start(psi);
if (process == null)
{
error = "无法启动 GC-SAVEDOG:Process.Start 返回 null(参数或路径问题)";
return false;
}
Console.WriteLine($"[update] GC-SAVEDOG 已启动: {exe}(PID {process.Id})");
return true;
}
catch (Exception ex)
{
error = ex.Message;
return false;
}
}
/// <summary>读取 SAVEDOG 最近一次的执行结果(供界面展示)。</summary>
public static SavedogState? ReadState(AppPaths paths)
=> Json.Read<SavedogState>(Path.Combine(paths.UpdateRoot, SavedogFiles.State));
/// <summary>上次成功启动的版本(回滚依据)。</summary>
public static LastGoodVersion? ReadLastGood(AppPaths paths)
=> Json.Read<LastGoodVersion>(Path.Combine(paths.UpdateRoot, SavedogFiles.LastGood));
}
-139
View File
@@ -1,139 +0,0 @@
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
namespace GC.Services;
/// <summary>
/// 双源选择:Xhmcl 与 GitCode 是同一份仓库的两个镜像。
///
/// 启动更新 / 下载页面 / 检查更新时,先并发探测两边的 version.json 响应时间,
/// 取**最快且内容可用**的那个作为本次下载源;探测结果缓存一段时间,
/// 避免每次点下载都重新测速。
/// </summary>
public sealed class SourceSelector : ISourceSelector
{
private static readonly HttpClient Http = CreateHttp();
private static HttpClient CreateHttp()
{
var c = new HttpClient { Timeout = TimeSpan.FromSeconds(6) };
c.DefaultRequestHeaders.UserAgent.ParseAdd("GC-Probe/1.0");
return c;
}
private readonly object _lock = new();
private SourcePreset? _cached;
private DateTime _cachedAt = DateTime.MinValue;
private readonly TimeSpan _ttl = TimeSpan.FromMinutes(3);
/// <summary>最近一次选中的源(未探测时为空)。</summary>
public SourcePreset? Current { get { lock (_lock) return _cached; } }
/// <summary>每个源的探测耗时(毫秒),供界面展示。</summary>
public IReadOnlyDictionary<string, long> LastLatency { get; private set; } =
new Dictionary<string, long>();
/// <summary>
/// 探测两个源并返回最快的。force=true 时忽略缓存。
/// 两个都失败时退回主源(Xhmcl):GitCode 镜像已停更,用它兜底只会拿到过期的
/// version.json —— 反而让人以为「没有更新」。
/// </summary>
public async Task<SourcePreset> PickFastestAsync(bool force = false, CancellationToken ct = default)
{
lock (_lock)
{
if (!force && _cached != null && DateTime.UtcNow - _cachedAt < _ttl)
return _cached;
}
var probes = SourcePreset.All.Select(async p =>
{
var sw = Stopwatch.StartNew();
var ok = await ProbeAsync(p, ct);
sw.Stop();
return (Preset: p, Ok: ok, Ms: sw.ElapsedMilliseconds);
});
var results = await Task.WhenAll(probes);
var latencies = results.ToDictionary(r => r.Preset.Id, r => r.Ms);
LastLatency = latencies;
var usable = results.Where(r => r.Ok).OrderBy(r => r.Ms).ToList();
// 全部探测失败时退回主源(SourcePreset.All 的第一项 = Xhmcl),
// 不要退回已停更的 GitCode 镜像。
var fallback = SourcePreset.All.Length > 0 ? SourcePreset.All[0] : SourcePreset.Xhmcl;
var chosen = usable.Count > 0 ? usable[0].Preset : fallback;
if (usable.Count == 0)
Console.WriteLine($"[selector] 所有源探测失败,退回主源 {chosen.Name}(稍后由实际请求再判定)");
lock (_lock)
{
_cached = chosen;
// 全部探测失败的结果不缓存:网络刚恢复时应该立刻重新测速,
// 而不是被一次失败的探测锁住 3 分钟。
_cachedAt = usable.Count > 0 ? DateTime.UtcNow : DateTime.MinValue;
}
Console.WriteLine("[selector] 测速:" + string.Join(" ",
results.Select(r => $"{r.Preset.Name}={r.Ms}ms{(r.Ok ? "" : "(不可用)")}"))
+ $" → 选择 {chosen.Name}");
return chosen;
}
/// <summary>
/// 探测:能拿到合法 JSON 才算可用。
/// 注意两个平台取文件的方式不同:
/// · Gitea(Xhmcl):raw/branch/{b}/{path} 直接返回文件内容
/// · GitCode:raw 地址返回的是 HTML 页面,必须走 API(内容为 base64)
/// 因此 GitCode 用 api/v5 contents + Accept: application/json 探测。
/// </summary>
private static async Task<bool> ProbeAsync(SourcePreset preset, CancellationToken ct)
{
if (preset.Kind == "gitcode")
{
try
{
using var cts = CancellationTokenSource.CreateLinkedTokenSource(ct);
cts.CancelAfter(TimeSpan.FromSeconds(5));
var api = $"{preset.ApiBase}/repos/{preset.Owner}/{preset.Repo}/contents/version.json?ref={preset.Branch}";
using var req = new HttpRequestMessage(HttpMethod.Get, api);
req.Headers.Accept.ParseAdd("application/json");
using var resp = await Http.SendAsync(req, cts.Token);
if (!resp.IsSuccessStatusCode) return false;
var text = await resp.Content.ReadAsStringAsync(cts.Token);
return text.TrimStart().StartsWith('{');
}
catch { return false; }
}
var urls = new[] { preset.RawUrl("version.json"), preset.RawUrl("model/version.json") };
foreach (var url in urls)
{
try
{
using var cts = CancellationTokenSource.CreateLinkedTokenSource(ct);
cts.CancelAfter(TimeSpan.FromSeconds(5));
var text = await Http.GetStringAsync(url, cts.Token);
if (text.TrimStart().StartsWith('{')) return true;
}
catch { /* 换下一个地址 */ }
}
return false;
}
/// <summary>为指定源创建对应的 remote 实现。</summary>
public static IModelRemote CreateRemote(SourcePreset preset) => preset.Kind switch
{
"gitea" => new GiteaRemote(preset),
_ => new GitCodeReleaseRemote(null, preset.HomeUrl)
};
}
-355
View File
@@ -1,355 +0,0 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Security.Cryptography;
using System.Threading;
using System.Threading.Tasks;
using GC.Models;
namespace GC.Services;
/// <summary>
/// 模型自动更新:读远端版本清单,把缺失/过期的模型下载到 cache 后原子替换
/// .GC/model/&lt;id&gt;,本次启动立即生效。任何失败都保留本地已装模型。
/// 启动器更新由 LauncherUpdater / LauncherUpdateFlow 独立负责,不在这里。
/// </summary>
public sealed class UpdateService : IUpdateService
{
private readonly AppPaths _paths;
private readonly SettingsService _settings;
private IModelRemote _remote;
public UpdateService(AppPaths paths, SettingsService settings, IModelRemote remote)
{
_paths = paths;
_settings = settings;
_remote = remote;
}
public IModelRemote Remote => _remote;
/// <summary>换源:测速选出最快的一个后,用它的 remote 覆盖当前实例。</summary>
public void UseRemote(IModelRemote remote) => _remote = remote;
/// <summary>
/// 同步版本(无法测速时用):按设置里的仓库地址映射到内置源。
/// 真正带测速的入口是 <see cref="CreateRemoteAsync"/>。
/// </summary>
public static IModelRemote CreateRemote(AppSettings settings)
{
if (!string.IsNullOrWhiteSpace(settings.UpdateLocalRoot) &&
Directory.Exists(settings.UpdateLocalRoot!))
return new DirectoryRemote(settings.UpdateLocalRoot!);
return SourceSelector.CreateRemote(SourcePreset.Detect(settings.UpdateRepository));
}
/// <summary>
/// 异步版本:先探测 Xhmcl / GitCode 两个源,取最快的那个。
/// 启动更新、下载页、检查更新统一走这里,保证「用同一个源、同一种下载方式」。
/// </summary>
public static async Task<IModelRemote> CreateRemoteAsync(AppSettings settings,
SourceSelector selector, bool forceProbe = false, CancellationToken ct = default)
{
if (!string.IsNullOrWhiteSpace(settings.UpdateLocalRoot) &&
Directory.Exists(settings.UpdateLocalRoot!))
return new DirectoryRemote(settings.UpdateLocalRoot!);
var preset = await selector.PickFastestAsync(forceProbe, ct);
return SourceSelector.CreateRemote(preset);
}
public async Task<UpdateResult> RunAsync(bool force,
IProgress<UpdateProgress>? progress, CancellationToken ct = default)
{
// 开发态的 model/ 里有源码与工程文件,模型自动替换会破坏源码目录,
// 因此开发态只做「启动器版本检查」(下载到 .GC/update 暂存,可验证链路),
// 跳过模型替换。要用正式流程验证请跑 ./build.sh update-test。
var devMode = _paths.IsDevelopment &&
Environment.GetEnvironmentVariable("EMS_DEV_UPDATE") != "1";
if (!force && !_settings.Current.AutoUpdateOnStartup)
return new UpdateResult { Outcome = UpdateOutcome.Disabled, Message = L.I["update.disabled"] };
progress?.Report(new UpdateProgress
{
Value = 0.02,
Message = L.I["update.checking"],
Detail = _remote.DisplayName
});
RepoVersion? remote;
try
{
remote = await _remote.GetVersionAsync(ct);
}
catch (OperationCanceledException) { throw; }
catch (Exception ex)
{
return new UpdateResult
{
Outcome = UpdateOutcome.Unavailable,
Message = L.I["update.offline"],
Error = ex.Message
};
}
if (remote == null)
return new UpdateResult
{
Outcome = UpdateOutcome.Unavailable,
Message = L.I["update.noManifest"]
};
// ---- 清单信任策略 --------------------------------------------------
// 签名有效 → 通过;没有签名 / 签名不符 → 默认拒绝(可用设置或环境变量放开)。
// 这一道闸门挡住的是「仓库被改、模型 dll 被换成木马」这类攻击。
var allowUnsigned = devMode ||
!_settings.Current.RequireSignedManifest ||
Environment.GetEnvironmentVariable("GC_ALLOW_UNSIGNED_MANIFEST") == "1";
if (!remote.IsTrusted)
{
var reason = remote.SignatureTrust == nameof(ManifestTrust.Invalid)
? "清单签名无效(内容可能被篡改)"
: "清单未签名";
if (!allowUnsigned)
{
Console.Error.WriteLine($"[update] {reason},已拒绝本次更新");
return new UpdateResult
{
Outcome = UpdateOutcome.Unavailable,
Message = $"{reason},已拒绝更新",
Error = remote.SignatureError
};
}
Console.Error.WriteLine($"[update] {reason},当前为开发/放宽模式,继续");
}
else
{
Console.WriteLine($"[update] 清单验签通过({remote.SignatureKeyId})");
}
_settings.Current.LastUpdateCheck = DateTime.UtcNow.ToString("O");
_settings.Save();
// 启动器更新由 LauncherUpdater / LauncherUpdateFlow 独立负责,
// 这里只做「模型同步到最新版」。
string? launcherMessage = null;
// ---- 同步所有模型到最新版 ----
// 开发态跳过:仓库 model/ 里有源码,整体替换会破坏工程目录。
var needed = devMode
? new List<RepoModel>()
: remote.Models.Where(NeedsModel).ToList();
var updated = new List<string>();
var errors = new List<string>();
for (var i = 0; i < needed.Count; i++)
{
var model = needed[i];
progress?.Report(new UpdateProgress
{
Value = 0.05 + 0.72 * i / Math.Max(1, needed.Count),
Message = L.I.F("update.downloadingModel", model.Id),
Detail = model.Version
});
try
{
await InstallModelAsync(model, progress, i, needed.Count, ct);
_settings.Current.InstalledModelVersions[model.Id] = model.Version;
_settings.Save();
updated.Add(model.Id);
}
catch (OperationCanceledException) { throw; }
catch (Exception ex)
{
errors.Add($"{model.Id}: {ex.Message}");
Console.Error.WriteLine($"模型更新失败 {model.Id}: {ex.Message}");
}
}
progress?.Report(new UpdateProgress { Value = 1, Message = L.I["update.done"] });
var outcome = errors.Count > 0
? UpdateOutcome.Partial
: (updated.Count > 0 || launcherMessage != null)
? UpdateOutcome.Applied
: UpdateOutcome.NoChange;
var message = updated.Count > 0
? L.I.F("update.applied", updated.Count)
: launcherMessage != null
? L.I["update.modelsLatest"]
: devMode
? "开发态:已检查启动器,模型替换已跳过(保护仓库源码)"
: L.I["update.noChange"];
if (errors.Count > 0) message += L.I.F("update.partial", errors.Count);
return new UpdateResult
{
Outcome = outcome,
Message = message,
UpdatedModels = updated.Count,
ModelNames = updated,
LauncherMessage = launcherMessage,
Error = errors.Count > 0 ? string.Join("; ", errors) : null
};
}
private bool NeedsModel(RepoModel model)
{
if (string.IsNullOrWhiteSpace(model.Id) || string.IsNullOrWhiteSpace(model.Version)) return false;
var dir = Path.Combine(_paths.ModelRoot, model.Id);
if (!Directory.Exists(dir)) return true;
if (!File.Exists(Path.Combine(dir, model.Id + ".json"))) return true;
return !_settings.Current.InstalledModelVersions.TryGetValue(model.Id, out var local) ||
!string.Equals(local, model.Version, StringComparison.OrdinalIgnoreCase);
}
/// <summary>只下载模型清单与模型数据目录,源码 / 文档不进运行目录。</summary>
private static bool IsPayload(string id, string relative)
{
var rel = relative.Replace('\\', '/');
// 拒绝任何形式的父目录穿越与绝对路径
if (rel.StartsWith('/') || rel.Contains("..", StringComparison.Ordinal)) return false;
return rel.Equals(id + ".json", StringComparison.OrdinalIgnoreCase) ||
rel.StartsWith(id + ".model/", StringComparison.OrdinalIgnoreCase);
}
private async Task InstallModelAsync(RepoModel model, IProgress<UpdateProgress>? progress,
int index, int count, CancellationToken ct)
{
var rootPath = string.IsNullOrWhiteSpace(model.Dir) ? "model/" + model.Id : model.Dir;
var entries = await _remote.ListTreeAsync(rootPath, ct);
var files = entries.Where(e => !e.IsDirectory && IsPayload(model.Id, e.RelativePath)).ToList();
if (!files.Any(e => e.RelativePath.Equals(model.Id + ".json", StringComparison.OrdinalIgnoreCase)))
throw new InvalidOperationException($"远端缺少模型清单 {model.Id}.json");
if (!files.Any(e => e.RelativePath.StartsWith(model.Id + ".model/", StringComparison.OrdinalIgnoreCase)))
throw new InvalidOperationException($"远端缺少模型数据 {model.Id}.model/");
var staging = Path.Combine(_paths.CacheRoot, "models", model.Id + "-" + Safe(model.Version));
if (Directory.Exists(staging)) Directory.Delete(staging, true);
Directory.CreateDirectory(staging);
try
{
var total = files.Sum(f => Math.Max(1L, f.Size));
// 并行下载:模型包通常有几十个文件,串行下载会明显拖慢启动。
// 并发上限 6,避免被服务端限流;进度用原子计数汇总。
long done = 0;
var stagingFull = Path.GetFullPath(staging)
.TrimEnd(Path.DirectorySeparatorChar) + Path.DirectorySeparatorChar;
using var gate = new SemaphoreSlim(6);
var tasks = files.Select(async entry =>
{
await gate.WaitAsync(ct);
try
{
ct.ThrowIfCancellationRequested();
var bytes = await _remote.DownloadAsync(entry, ct);
// 路径穿越防护
var dest = Path.GetFullPath(Path.Combine(staging,
entry.RelativePath.Replace('/', Path.DirectorySeparatorChar)));
if (!dest.StartsWith(stagingFull, StringComparison.OrdinalIgnoreCase))
throw new InvalidOperationException($"非法的模型文件路径: {entry.RelativePath}");
var destDir = Path.GetDirectoryName(dest);
if (!string.IsNullOrEmpty(destDir)) Directory.CreateDirectory(destDir);
await File.WriteAllBytesAsync(dest, bytes, ct);
var now = Interlocked.Add(ref done, bytes.Length);
progress?.Report(new UpdateProgress
{
Value = 0.05 + 0.72 * (index + Math.Min(1, (double)now / Math.Max(1, total))) / Math.Max(1, count),
Message = L.I.F("update.downloadingModel", model.Id),
Detail = entry.RelativePath
});
}
finally { gate.Release(); }
});
await Task.WhenAll(tasks);
// ---- 完整性校验:清单是签过名的,里面的哈希就是"正版"的定义 --------
// 下载到暂存目录后按同一算法复算,不一致直接丢弃,绝不安装。
var computed = ModelIntegrity.Compute(staging, model.Id);
if (!string.IsNullOrWhiteSpace(model.ManifestSha256) &&
!string.Equals(computed.ManifestSha256, model.ManifestSha256,
StringComparison.OrdinalIgnoreCase))
throw new InvalidOperationException(
$"模型清单哈希不符(期望 {Short(model.ManifestSha256)},实际 {Short(computed.ManifestSha256)})");
if (!string.IsNullOrWhiteSpace(model.FilesSha256) &&
!string.Equals(computed.FilesSha256, model.FilesSha256,
StringComparison.OrdinalIgnoreCase))
throw new InvalidOperationException(
$"模型文件哈希不符(期望 {Short(model.FilesSha256)},实际 {Short(computed.FilesSha256)}),已丢弃");
// 原子替换:先备份旧目录,成功后再删备份;失败自动回滚
Directory.CreateDirectory(_paths.ModelRoot);
var target = Path.Combine(_paths.ModelRoot, model.Id);
// 双保险:任何情况下都不允许把含 src/ 源码的模型目录整体换掉
if (Directory.Exists(Path.Combine(target, "src")))
throw new InvalidOperationException($"目标目录含模型源码 src/,拒绝覆盖: {target}");
var backup = target + ".old";
if (Directory.Exists(backup)) Directory.Delete(backup, true);
if (Directory.Exists(target)) Directory.Move(target, backup);
try
{
Directory.Move(staging, target);
}
catch
{
if (Directory.Exists(backup) && !Directory.Exists(target)) Directory.Move(backup, target);
throw;
}
if (Directory.Exists(backup))
{
try { Directory.Delete(backup, true); } catch { /* 占用时留到下次 */ }
}
// 安装成功:把完整性记录写进模型目录,加载 dll 前会再抽查一次
try
{
ModelIntegrity.Write(target, model.Id, new ModelIntegrityFile
{
Id = model.Id,
Version = model.Version,
ManifestSha256 = computed.ManifestSha256,
FilesSha256 = computed.FilesSha256,
Files = computed.Files,
InstalledAt = DateTime.UtcNow.ToString("yyyy-MM-ddTHH:mm:ssZ"),
Source = _remote.DisplayName
});
}
catch (Exception ex)
{
Console.Error.WriteLine($"写入完整性记录失败 {model.Id}: {ex.Message}");
}
}
catch
{
try { if (Directory.Exists(staging)) Directory.Delete(staging, true); } catch { }
throw;
}
}
private static string Safe(string value)
{
foreach (var c in Path.GetInvalidFileNameChars()) value = value.Replace(c, '-');
return value.Replace('/', '-').Replace(' ', '-');
}
private static string Short(string? hash)
=> string.IsNullOrEmpty(hash) ? "(空)" : hash!.Length <= 8 ? hash : hash[..8];
}
-42
View File
@@ -1,42 +0,0 @@
using System;
using System.Globalization;
namespace GC.Services;
/// <summary>
/// 版本号工具:Release tag 有 v1.0.6 / GCL-1.0.6 / GC-1.0.6 / 1.0.6 等写法,
/// 统一成可比较的 Version 再排序,挑**版本号最高**的那个。
/// </summary>
public static class VersionUtil
{
/// <summary>把 tag 规整成 "1.0.6" 这样的纯数字版本。</summary>
public static string Normalize(string? tag)
{
if (string.IsNullOrWhiteSpace(tag)) return "";
var s = tag!.Trim();
// 去掉前缀:v / V / GC- / GCL- / release-
if (s.StartsWith("GCL-", StringComparison.OrdinalIgnoreCase)) s = s[4..];
else if (s.StartsWith("GC-", StringComparison.OrdinalIgnoreCase)) s = s[3..];
else if (s.StartsWith("release-", StringComparison.OrdinalIgnoreCase)) s = s[8..];
s = s.TrimStart('v', 'V');
// 只保留开头的 数字与点
var end = 0;
while (end < s.Length && (char.IsDigit(s[end]) || s[end] == '.')) end++;
s = s[..end].Trim('.');
return s;
}
/// <summary>解析成 Version;无法解析时返回 0.0。</summary>
public static Version Parse(string? tag)
{
var n = Normalize(tag);
if (string.IsNullOrWhiteSpace(n)) return new Version(0, 0);
return Version.TryParse(n, out var v) ? v : new Version(0, 0);
}
/// <summary>比较两个版本号,a>b 返回正、a&lt;b 返回负、相等返回 0。</summary>
public static int Compare(string? a, string? b) => Parse(a).CompareTo(Parse(b));
}
-22
View File
@@ -1,22 +0,0 @@
using System;
using System.IO;
namespace GC.Services;
/// <summary>
/// 安全解压的统一入口(实现在 <see cref="SafeArchive"/>)。
/// 保留这个名字是因为模型源导入 / 启动器更新两处都在用,
/// 真正的校验逻辑集中在一处,避免两套实现走偏。
/// </summary>
public static class ZipSafety
{
public static void ExtractToDirectory(string zipPath, string destination)
{
if (!File.Exists(zipPath))
throw new FileNotFoundException("压缩包不存在", zipPath);
SafeArchive.ExtractToDirectory(zipPath, destination);
}
/// <summary>只检查不落盘:给下载完成后的预检用。</summary>
public static SafeArchive.Inspection Inspect(string zipPath) => SafeArchive.Inspect(zipPath);
}
-642
View File
@@ -1,642 +0,0 @@
using System;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text.Json;
using Avalonia;
using Avalonia.Animation;
using Avalonia.Animation.Easings;
using Avalonia.Controls;
using Avalonia.Input;
using Avalonia.Layout;
using Avalonia.Media;
using Shapes = Avalonia.Controls.Shapes;
using Avalonia.VisualTree;
using GC.Models;
using GC.Services;
namespace GC.Views;
/// <summary>
/// 模型窗口:**只做窗口宿主**。
/// 内容完全来自模型程序集(<see cref="LoadedModel.View"/>),启动器不渲染任何东西。
/// 快捷键:Esc 关闭窗口,F11 全屏。
/// </summary>
public sealed class PlayerWindow : Window
{
private LoadedModel? _model;
private bool _closing;
private Button? _maximizeButton;
private Border? _frame;
private TextBlock? _titleText;
private Border? _titleBar;
private readonly List<Button> _titleButtons = new();
private readonly List<Shapes.Path> _titleGlyphs = new();
private Shapes.Path? _maximizeGlyph;
private Shapes.Path? _restoreGlyph;
private string _maxMaxPath = "";
private string _maxRestorePath = "";
private Button? _helpButton;
/// <summary>基准尺寸(1240×820 时的标题栏高度与按钮尺寸)。</summary>
private const double BaseWidth = 1240;
private const double BaseTitleBarHeight = 34;
private const double BaseButtonWidth = 38;
private const double BaseButtonHeight = 28;
private const double BaseTitleFont = 11.5;
private const double BaseHelpFont = 11.5;
public PlayerWindow(ModelPackage package, LoadedModel model)
{
_model = model;
Title = package.LocalizedName;
Width = 1240;
Height = 820;
MinWidth = 1000;
MinHeight = 680;
Background = Brushes.Transparent;
TransparencyLevelHint = new[] { WindowTransparencyLevel.Transparent };
WindowStartupLocation = WindowStartupLocation.CenterOwner;
// 与启动器一致:去掉系统标题栏,自己做一个极简顶栏(否则 Esc 之外无法关闭)
SystemDecorations = Avalonia.Controls.SystemDecorations.None;
// 标题栏配色来自模型清单,跟随模型自己的界面风格:
// 地球模型是深色舞台,比例尺计算器是浅色卡片,两者不能共用一套深色。
var chrome = package.Manifest.Chrome;
var barBg = ParseColor(chrome?.TitleBar, "#0C1828");
var barBorder = ParseColor(chrome?.TitleBorder, "#1B2740");
var barText = ParseColor(chrome?.TitleText, "#EAF2FF");
var btnText = ParseColor(chrome?.Button, "#9FB4D4");
var frameBg = ParseColor(chrome?.Frame, "#0A1524");
var titleText = new TextBlock
{
Text = package.LocalizedName,
Foreground = new SolidColorBrush(barText),
FontSize = 11.5,
Margin = new Thickness(14, 0, 0, 0),
VerticalAlignment = VerticalAlignment.Center,
[Grid.ColumnProperty] = 0
};
_titleText = titleText;
var helpButton = new Button
{
Content = IsEnglish() ? "How to use?" : "如何使用?",
Height = 26,
Padding = new Thickness(12, 0),
Background = Brushes.Transparent,
Foreground = new SolidColorBrush(btnText),
BorderThickness = new Thickness(0),
FontSize = 11.5,
CornerRadius = new CornerRadius(7),
Margin = new Thickness(0, 0, 6, 0),
HorizontalContentAlignment = HorizontalAlignment.Center,
VerticalContentAlignment = VerticalAlignment.Center,
Cursor = new Cursor(StandardCursorType.Hand),
[Grid.ColumnProperty] = 1
};
helpButton.Click += (_, _) => ShowHelp(package, barBg, barBorder, barText, btnText, frameBg);
// 标题栏三键:最小化 / 最大化 / 关闭 —— 卡通画风。
// 每颗按钮 = 彩色实心圆底 + 粗圆头描边图标,像一颗小糖豆。
(Button Btn, Shapes.Path Icon) MakeBadge(int column, string iconPath)
{
// 纯矢量图标,没有彩色圆圈
var icon = new Shapes.Path
{
Data = Geometry.Parse(iconPath),
Stroke = new SolidColorBrush(btnText),
StrokeThickness = 1.5,
StrokeLineCap = PenLineCap.Round,
StrokeJoin = PenLineJoin.Round,
Fill = null,
Stretch = Stretch.None,
Width = 10,
Height = 10,
HorizontalAlignment = HorizontalAlignment.Center,
VerticalAlignment = VerticalAlignment.Center
};
var layer = new Grid
{
HorizontalAlignment = HorizontalAlignment.Center,
VerticalAlignment = VerticalAlignment.Center
};
layer.Children.Add(icon);
var b = new Button
{
Width = 38,
Height = 28,
Background = Brushes.Transparent,
BorderThickness = new Thickness(0),
CornerRadius = new CornerRadius(9),
Padding = new Thickness(0),
Margin = new Thickness(2, 0, 0, 0),
Content = layer,
HorizontalContentAlignment = HorizontalAlignment.Center,
VerticalContentAlignment = VerticalAlignment.Center,
Cursor = new Cursor(StandardCursorType.Hand),
[Grid.ColumnProperty] = column
};
var hoverBg = IsLight(barBg)
? new SolidColorBrush(Color.Parse("#EEF1F7"))
: new SolidColorBrush(Color.Parse("#1E2C46"));
var isCloseBtn = column == 4;
b.PointerEntered += (_, _) =>
{
b.Background = hoverBg;
icon.Stroke = new SolidColorBrush(isCloseBtn ? Colors.White
: IsLight(barBg) ? Color.Parse("#111A2E") : Colors.White);
};
b.PointerExited += (_, _) =>
{
b.Background = Brushes.Transparent;
icon.Stroke = new SolidColorBrush(btnText);
};
b.Classes.Add("model-titlebtn");
_titleButtons.Add(b);
_titleGlyphs.Add(icon);
return (b, icon);
}
// 卡通配色:暖黄 / 薄荷绿 / 珊瑚红
var minBadge = MakeBadge(2, "M1.5,5 L8.5,5");
var maxBadge = MakeBadge(3, "M2.2,2.2 L7.8,2.2 L7.8,7.8 L2.2,7.8 Z");
var closeBadge = MakeBadge(4, "M2,2 L8,8 M8,2 L2,8");
var minimizeButton = minBadge.Btn;
var maximizeButton = maxBadge.Btn;
var closeButton = closeBadge.Btn;
minimizeButton.Click += (_, _) => WindowState = WindowState.Minimized;
maximizeButton.Click += (_, _) => ToggleMaximize();
closeButton.Click += (_, _) => _ = CloseWithAnimationAsync();
_maximizeGlyph = maxBadge.Icon;
_restoreGlyph = maxBadge.Icon;
_maxRestorePath = "M2.6,3.6 L7.4,3.6 L7.4,8.4 L2.6,8.4 Z M2.6,3.6 L2.6,1.6 L7.4,1.6 L7.4,6.4";
_maxMaxPath = "M2.2,2.2 L7.8,2.2 L7.8,7.8 L2.2,7.8 Z";
var titleBar = new Border
{
Height = 34,
Background = new SolidColorBrush(barBg),
BorderBrush = new SolidColorBrush(barBorder),
BorderThickness = new Thickness(0, 0, 0, 1),
Child = new Grid
{
ColumnDefinitions = new ColumnDefinitions("*,Auto,Auto,Auto,Auto,Auto"),
Margin = new Thickness(0, 0, 10, 0),
Children = { titleText, helpButton, minimizeButton, maximizeButton, closeButton }
}
};
titleBar.PointerPressed += OnTitleBarPointerPressed;
// 双击标题栏 = 最大化 / 还原(与系统标题栏一致)
titleBar.DoubleTapped += (_, e) =>
{
if (e.Source is Button) return;
ToggleMaximize();
};
_maximizeButton = maximizeButton;
_titleBar = titleBar;
_helpButton = helpButton;
_titleButtons.Add(minimizeButton);
_titleButtons.Add(maximizeButton);
_titleButtons.Add(closeButton);
var dock = new DockPanel { LastChildFill = true };
DockPanel.SetDock(titleBar, Dock.Top);
dock.Children.Add(titleBar);
dock.Children.Add(model.View);
Content = new Border
{
CornerRadius = new CornerRadius(16),
Background = new SolidColorBrush(frameBg),
ClipToBounds = true,
Child = dock
};
_frame = (Border)Content;
// 最大化 / 还原时同步圆角与按钮图标
PropertyChanged += (_, e) =>
{
if (e.Property == WindowStateProperty) UpdateMaximizeVisual();
};
// 窗口随心拉大 / 拉小时,标题栏文字与按钮同比缩放。
// 同时监听 Bounds 属性(不只是 SizeChanged),保证最大化/还原也立刻生效。
SizeChanged += (_, _) => ApplyChromeScale();
PropertyChanged += (_, e) =>
{
if (e.Property == BoundsProperty) ApplyChromeScale();
};
ApplyChromeScale();
KeyDown += OnKeyDown;
Closed += OnClosed;
}
/// <summary>
/// 让标题栏的文字与按钮尺寸跟随窗口大小。
/// 以 1240px 宽为基准线性缩放,限制在 0.85–1.9 倍,
/// 避免最大化到 4K 时按钮大得离谱、缩到最小又点不中。
/// </summary>
private void ApplyChromeScale()
{
if (Bounds.Width < 100) return;
var scale = Math.Clamp(Bounds.Width / BaseWidth, 0.85, 1.9);
if (_titleBar != null) _titleBar.Height = Math.Round(BaseTitleBarHeight * scale);
foreach (var b in _titleButtons)
{
b.Width = Math.Round(BaseButtonWidth * scale);
b.Height = Math.Round(BaseButtonHeight * scale);
b.FontSize = Math.Round(13 * scale, 1);
b.CornerRadius = new CornerRadius(Math.Round(7 * scale, 1));
}
if (_helpButton != null)
{
_helpButton.Height = Math.Round(26 * scale);
_helpButton.FontSize = Math.Round(BaseHelpFont * scale, 1);
_helpButton.Padding = new Thickness(Math.Round(12 * scale), 0);
_helpButton.CornerRadius = new CornerRadius(Math.Round(7 * scale, 1));
}
foreach (var g in _titleGlyphs)
{
g.Width = Math.Round(10 * scale, 1);
g.Height = Math.Round(10 * scale, 1);
g.StrokeThickness = Math.Round(1.5 * scale, 2);
}
if (_titleText != null)
{
_titleText.FontSize = Math.Round(BaseTitleFont * scale, 1);
_titleText.Margin = new Thickness(Math.Round(14 * scale), 0, 0, 0);
}
}
/// <summary>判断颜色是否属于浅色系(用于决定悬停用深色还是浅色)。</summary>
private static bool IsLight(Color c)
{
// 相对亮度(sRGB 近似)
var lum = (0.299 * c.R + 0.587 * c.G + 0.114 * c.B) / 255.0;
return lum > 0.6;
}
private void ToggleMaximize()
{
WindowState = WindowState == WindowState.Maximized
? WindowState.Normal
: WindowState.Maximized;
}
private void UpdateMaximizeVisual()
{
var max = WindowState == WindowState.Maximized || WindowState == WindowState.FullScreen;
if (_maximizeGlyph != null)
{
// 只换 Data,不换控件对象(换对象会触发 "already has a parent")
_maximizeGlyph.Data = Geometry.Parse(max ? _maxRestorePath : _maxMaxPath);
}
if (_maximizeButton != null)
{
Avalonia.Controls.ToolTip.SetTip(_maximizeButton, max
? (IsEnglish() ? "Restore" : "还原")
: (IsEnglish() ? "Maximize" : "最大化"));
}
// 最大化后同样保留圆角(用户要求:任何状态都要圆角)
if (_frame != null) _frame.CornerRadius = new CornerRadius(16);
}
private static Color ParseColor(string? hex, string fallback)
{
if (!string.IsNullOrWhiteSpace(hex))
{
try { return Color.Parse(hex!); }
catch { /* 模型写错颜色时退回默认 */ }
}
return Color.Parse(fallback);
}
private static bool IsEnglish() => L.I.Language.StartsWith("en", StringComparison.OrdinalIgnoreCase);
/// <summary>
/// 「如何使用?」:读取模型自带数据目录里的 help.json(中英双语),
/// 用与标题栏一致的配色弹出一个独立小窗。说明内容完全由模型提供,启动器不内置文案。
/// </summary>
private void ShowHelp(ModelPackage package, Color barBg, Color barBorder, Color barText,
Color btnText, Color frameBg)
{
var lang = IsEnglish() ? "en" : "zh-CN";
var file = Path.Combine(package.DataDirectory, "help.json");
string title = IsEnglish() ? "How to use" : "如何使用";
// 分节内容:每节一个标题 + 若干条说明;兼容旧的扁平 lines 格式
var sections = new List<(string Heading, List<string> Lines)>();
if (File.Exists(file))
{
try
{
using var doc = JsonDocument.Parse(File.ReadAllText(file));
var root = doc.RootElement;
var node = root.TryGetProperty(lang, out var exact) ? exact
: root.TryGetProperty("zh-CN", out var zh) ? zh : root;
if (node.TryGetProperty("title", out var t)) title = t.GetString() ?? title;
if (node.TryGetProperty("sections", out var arr) && arr.ValueKind == JsonValueKind.Array)
{
foreach (var sec in arr.EnumerateArray())
{
var heading = sec.TryGetProperty("h", out var h) ? h.GetString() ?? "" : "";
var items = new List<string>();
if (sec.TryGetProperty("lines", out var ls) && ls.ValueKind == JsonValueKind.Array)
foreach (var item in ls.EnumerateArray())
if (item.ValueKind == JsonValueKind.String) items.Add(item.GetString() ?? "");
if (items.Count > 0) sections.Add((heading, items));
}
}
else if (node.TryGetProperty("lines", out var flat) && flat.ValueKind == JsonValueKind.Array)
{
var items = new List<string>();
foreach (var item in flat.EnumerateArray())
if (item.ValueKind == JsonValueKind.String) items.Add(item.GetString() ?? "");
if (items.Count > 0) sections.Add(("", items));
}
}
catch (Exception ex)
{
Console.Error.WriteLine($"读取模型帮助失败 {file}: {ex.Message}");
}
}
if (sections.Count == 0)
sections.Add(("", new List<string>
{
IsEnglish() ? "This model has no usage notes yet." : "该模型暂未提供使用说明。"
}));
var body = new StackPanel { Spacing = 6 };
foreach (var (heading, items) in sections)
{
if (!string.IsNullOrWhiteSpace(heading))
body.Children.Add(new TextBlock
{
Text = heading,
Foreground = new SolidColorBrush(barText),
FontSize = 13.5,
FontWeight = FontWeight.SemiBold,
Margin = new Thickness(0, 12, 0, 2)
});
foreach (var line in items)
body.Children.Add(new TextBlock
{
Text = "• " + line,
Foreground = new SolidColorBrush(btnText),
FontSize = 12.5,
TextWrapping = TextWrapping.Wrap,
LineHeight = 19
});
}
// ── 帮助窗口自建标题栏(带 ✕),与模型窗口同款配色 ──
// 纯矢量图标,无彩色圆底(与三个窗口按钮保持一致)
var helpCross = new Shapes.Path
{
Data = Geometry.Parse("M2,2 L8,8 M8,2 L2,8"),
Stroke = new SolidColorBrush(btnText),
StrokeThickness = 1.5,
StrokeLineCap = PenLineCap.Round,
Fill = null,
Stretch = Stretch.None,
Width = 10, Height = 10,
HorizontalAlignment = HorizontalAlignment.Center,
VerticalAlignment = VerticalAlignment.Center
};
var helpClose = new Button
{
Content = helpCross,
Width = 34,
Height = 26,
Background = Brushes.Transparent,
BorderThickness = new Thickness(0),
CornerRadius = new CornerRadius(9),
Padding = new Thickness(0),
Margin = new Thickness(6, 0, 0, 0),
HorizontalContentAlignment = HorizontalAlignment.Center,
VerticalContentAlignment = VerticalAlignment.Center,
Cursor = new Cursor(StandardCursorType.Hand)
};
helpClose.PointerEntered += (_, _) =>
{
helpClose.Background = new SolidColorBrush(IsLight(frameBg)
? Color.Parse("#EEF1F7") : Color.Parse("#1E2C46"));
helpCross.Stroke = new SolidColorBrush(Colors.White);
};
helpClose.PointerExited += (_, _) =>
{
helpClose.Background = Brushes.Transparent;
helpCross.Stroke = new SolidColorBrush(btnText);
};
var helpTitle = new TextBlock
{
Text = title,
Foreground = new SolidColorBrush(barText),
FontSize = 16,
FontWeight = FontWeight.SemiBold,
VerticalAlignment = VerticalAlignment.Center
};
var helpBarGrid = new Grid
{
ColumnDefinitions = new ColumnDefinitions("*,Auto"),
Margin = new Thickness(22, 0, 14, 0)
};
helpBarGrid.Children.Add(helpTitle);
Grid.SetColumn(helpClose, 1);
helpBarGrid.Children.Add(helpClose);
var helpTitleBar = new Border
{
Height = 48,
Background = new SolidColorBrush(barBg),
BorderBrush = new SolidColorBrush(barBorder),
BorderThickness = new Thickness(0, 0, 0, 1),
Child = helpBarGrid
};
helpTitleBar.PointerPressed += (_, e) =>
{
if (e.GetCurrentPoint(helpTitleBar).Properties.IsLeftButtonPressed)
helpClose.FindAncestorOfType<Window>()?.BeginMoveDrag(e);
};
// ── 底部固定操作条:无论正文多长,「知道了」始终可见 ──
var ok = new Button
{
Content = IsEnglish() ? "Got it" : "知道了",
HorizontalAlignment = HorizontalAlignment.Right,
Padding = new Thickness(20, 8),
Background = new SolidColorBrush(Color.Parse("#2F6BFF")),
Foreground = new SolidColorBrush(Colors.White),
BorderThickness = new Thickness(0),
CornerRadius = new CornerRadius(8),
Cursor = new Cursor(StandardCursorType.Hand)
};
var footer = new Border
{
Padding = new Thickness(24, 10, 24, 14),
BorderBrush = new SolidColorBrush(barBorder),
BorderThickness = new Thickness(0, 1, 0, 0),
Child = ok
};
// 标题栏(顶) + 正文(中,滚动) + 操作条(底,固定)
var rootPanel = new DockPanel { LastChildFill = true };
DockPanel.SetDock(helpTitleBar, Dock.Top);
rootPanel.Children.Add(helpTitleBar);
DockPanel.SetDock(footer, Dock.Bottom);
rootPanel.Children.Add(footer);
var scroll = new ScrollViewer
{
Content = new Border
{
Margin = new Thickness(24, 14, 24, 10),
Child = body
},
VerticalScrollBarVisibility = Avalonia.Controls.Primitives.ScrollBarVisibility.Auto,
HorizontalScrollBarVisibility = Avalonia.Controls.Primitives.ScrollBarVisibility.Disabled
};
rootPanel.Children.Add(scroll);
var win = new Window
{
Title = title,
Width = 660,
Height = Math.Min(760, 230 + sections.Sum(s => s.Lines.Count * 24 + 40)),
MinWidth = 480,
MinHeight = 320,
Background = Brushes.Transparent,
TransparencyLevelHint = new[] { WindowTransparencyLevel.Transparent },
SystemDecorations = SystemDecorations.None,
WindowStartupLocation = WindowStartupLocation.CenterOwner,
Content = new Border
{
CornerRadius = new CornerRadius(16),
Background = new SolidColorBrush(frameBg),
BorderBrush = new SolidColorBrush(barBorder),
BorderThickness = new Thickness(1),
ClipToBounds = true,
Child = rootPanel
}
};
ok.Click += (_, _) => win.Close();
helpClose.Click += (_, _) => win.Close();
win.Show(this);
}
private void OnTitleBarPointerPressed(object? sender, PointerPressedEventArgs e)
{
if (e.GetCurrentPoint(this).Properties.IsLeftButtonPressed)
BeginMoveDrag(e);
}
private void OnKeyDown(object? sender, KeyEventArgs e)
{
switch (e.Key)
{
case Key.Escape:
_ = CloseWithAnimationAsync();
e.Handled = true;
break;
case Key.F11:
WindowState = WindowState == WindowState.FullScreen
? WindowState.Normal
: WindowState.FullScreen;
e.Handled = true;
break;
}
}
/// <summary>
/// 关闭动画:淡出 + 轻微缩小,动画结束后再真正关闭窗口。
/// 与主窗口的关闭动画保持同一节奏(180ms)。
/// </summary>
private async Task CloseWithAnimationAsync()
{
if (_closing) return;
_closing = true;
Transitions = new Transitions
{
new DoubleTransition
{
Property = OpacityProperty,
Duration = TimeSpan.FromMilliseconds(180),
Easing = new CubicEaseIn()
}
};
Opacity = 0;
await Task.Delay(190);
Close();
}
private void OnClosed(object? sender, EventArgs e)
{
Content = null;
_model?.Dispose();
_model = null;
}
}
/// <summary>模型加载失败时显示的提示窗口(不含任何渲染逻辑)。</summary>
public sealed class ModelErrorWindow : Window
{
public ModelErrorWindow(string title, string message)
{
Title = title;
Width = 560;
Height = 340;
Background = Brushes.Transparent;
TransparencyLevelHint = new[] { WindowTransparencyLevel.Transparent };
WindowStartupLocation = WindowStartupLocation.CenterOwner;
var lines = new List<Control>
{
new TextBlock
{
Text = title,
Foreground = new SolidColorBrush(Color.Parse("#F2F6FF")),
FontSize = 16,
FontWeight = FontWeight.SemiBold
},
new TextBlock
{
Text = message,
Foreground = new SolidColorBrush(Color.Parse("#8CA0C4")),
FontSize = 12,
TextWrapping = TextWrapping.Wrap
},
new Button
{
Content = "确定",
HorizontalAlignment = Avalonia.Layout.HorizontalAlignment.Right,
Padding = new Thickness(18, 6)
}
};
var panel = new StackPanel
{
Margin = new Thickness(24),
Spacing = 14
};
foreach (var line in lines) panel.Children.Add(line);
if (lines[^1] is Button ok) ok.Click += (_, _) => Close();
Content = new Border
{
CornerRadius = new CornerRadius(12),
Background = new SolidColorBrush(Color.Parse("#0B1226")),
Child = panel
};
}
}
-838
View File
@@ -1,838 +0,0 @@
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text.RegularExpressions;
using System.Threading;
using GC.Services;
namespace GC.Savedog;
internal sealed class ApplyOptions
{
public string UpdateDir { get; set; } = "";
public string? InstallDir { get; set; }
public int WaitPid { get; set; }
public int TimeoutSeconds { get; set; } = 45;
public bool RequireSignature { get; set; } = true;
public bool DryRun { get; set; }
public bool Force { get; set; }
}
/// <summary>
/// 应用一次启动器更新:验签 → 校验 → 原子替换 → 启动 → 看护 → 成功清场 / 失败回滚。
/// 任何一步失败都不会留下「删了旧版又没有新版」的状态。
/// </summary>
internal sealed class Applier
{
private readonly ApplyOptions _options;
private readonly Log _log;
/// <summary>发布包里的启动器文件名:GC-1.0.9-win-amd64.exe。</summary>
private static readonly Regex VersionedExePattern = new(
@"^(?:GC|GCL)-\d+(?:\.\d+)+-[A-Za-z0-9]+-[A-Za-z0-9]+\.exe$",
RegexOptions.IgnoreCase | RegexOptions.CultureInvariant | RegexOptions.Compiled);
public Applier(ApplyOptions options, Log log)
{
_options = options;
_log = log;
}
public int Run()
{
var updateDir = Path.GetFullPath(_options.UpdateDir);
var requestPath = Path.Combine(updateDir, SavedogFiles.ApplyRequest);
if (!File.Exists(requestPath))
return Fail(updateDir, "找不到更新申请 " + SavedogFiles.ApplyRequest, 3,
"Update request not found: " + SavedogFiles.ApplyRequest);
var request = Json.Read<SavedogRequest>(requestPath);
if (request == null || string.IsNullOrWhiteSpace(request.Version))
return Fail(updateDir, "更新申请内容不完整", 3, "The update request is incomplete");
if (!ValidName(request.PackageName))
return Fail(updateDir, "更新包名不合法: " + request.PackageName, 3,
"Invalid package name: " + request.PackageName);
_log.Info($"开始应用 v{request.Version}({request.Rid},{request.PackageName})",
$"Starting apply of v{request.Version} ({request.Rid}, {request.PackageName})");
// 1. 等旧进程退出(否则 Windows 上文件还被占用)
if (_options.WaitPid > 0 && !WaitForExit(_options.WaitPid, TimeSpan.FromSeconds(60)))
_log.Warn($"等待进程 {_options.WaitPid} 退出超时,继续尝试",
$"Timed out waiting for process {_options.WaitPid} to exit; continuing anyway");
// 2. 安装目录定位与安全检查
var installDir = string.IsNullOrWhiteSpace(_options.InstallDir)
? Path.GetFullPath(Path.Combine(updateDir, request.InstallRelative))
: Path.GetFullPath(_options.InstallDir!);
if (!Directory.Exists(installDir))
return Fail(updateDir, "安装目录不存在: " + installDir, 4,
"Install directory does not exist: " + installDir);
if (!_options.Force && File.Exists(Path.Combine(installDir, "GC.sln")))
return Fail(updateDir, "检测到源码目录,拒绝在源码树里替换程序", 4,
"Source tree detected; refusing to replace files inside it");
// 3. 二次验签:不信任「启动器说它验过了」
var require = request.RequireSignature && SignatureKeyring.Enforced;
var manifestPath = Path.Combine(updateDir, request.ManifestPath);
var manifestText = File.Exists(manifestPath) ? File.ReadAllText(manifestPath) : null;
var verification = ManifestSignature.Verify(manifestText, require);
// 签名不对(被改过 / 密钥不认识)永远拒绝;仅「没有签名」在明确不强制时放行。
// 之前这里不看 require:即使调用方声明 requireSignature=false(开发态、测试),
// 未签名清单也会被当成验签失败直接拒掉。
var hostile = verification.Trust == ManifestTrust.Invalid;
if (hostile || (verification.IsRejected && require))
{
_log.Error($"清单验签失败({verification.Trust}):{verification.Error}",
$"Manifest signature check failed ({verification.Trust}): {verification.Error}");
return Refuse(updateDir, request, verification);
}
if (verification.IsRejected)
{
_log.Warn($"清单未签名,按调用方要求放行:{verification.Error}",
$"Manifest is unsigned; continuing as requested: {verification.Error}");
}
_log.Info($"清单可信度:{verification.Trust}" +
(verification.KeyId != null ? $"({verification.KeyId})" : ""),
$"Manifest trust: {verification.Trust}" +
(verification.KeyId != null ? $" ({verification.KeyId})" : ""));
// 4. 校验更新包
var zipPath = Path.Combine(updateDir, request.PackageZip);
if (!File.Exists(zipPath))
return Fail(updateDir, "更新包不存在: " + request.PackageZip, 5,
"Package not found: " + request.PackageZip);
var zipInfo = new FileInfo(zipPath);
if (request.PackageSize > 0 && zipInfo.Length != request.PackageSize)
return Fail(updateDir, $"更新包体积不符(期望 {request.PackageSize},实际 {zipInfo.Length})", 5,
$"Package size mismatch (expected {request.PackageSize}, got {zipInfo.Length})");
var actualSha = ContentHash.Sha256File(zipPath);
if (!string.IsNullOrWhiteSpace(request.PackageSha256) &&
!string.Equals(actualSha, request.PackageSha256, StringComparison.OrdinalIgnoreCase))
{
return Fail(updateDir, "更新包 sha256 与清单不符,已丢弃", 5,
"Package sha256 does not match the manifest; discarded");
}
if (string.IsNullOrWhiteSpace(request.PackageSha256))
_log.Warn("清单没有提供 sha256,仅依赖签名与解压校验",
"Manifest has no sha256; relying on the signature and extraction checks only");
SafeArchive.Inspection inspection;
try
{
inspection = SafeArchive.Inspect(zipPath);
_log.Info($"更新包检查通过:{inspection.Entries} 个条目," +
$"{inspection.UncompressedBytes / 1024 / 1024} MB,压缩比 {inspection.Ratio:0.0}:1",
$"Package inspection passed: {inspection.Entries} entries, " +
$"{inspection.UncompressedBytes / 1024 / 1024} MB, ratio {inspection.Ratio:0.0}:1");
}
catch (Exception ex)
{
return Fail(updateDir, "更新包安全性检查失败: " + ex.Message, 5,
"Package safety check failed: " + ex.Message);
}
// 5. 解压到暂存区(与安装目录同卷,后续 rename 才是原子的)
var stage = Path.Combine(updateDir, "stage");
ClearDirectory(stage);
try
{
SafeArchive.ExtractToDirectory(zipPath, stage);
FlattenSingleDirectory(stage);
}
catch (Exception ex)
{
ClearDirectory(stage);
return Fail(updateDir, "解压失败: " + ex.Message, 6, "Extraction failed: " + ex.Message);
}
var artifact = FindArtifact(stage, request.PackageName);
if (artifact == null)
{
ClearDirectory(stage);
return Fail(updateDir, "更新包里没有找到新版程序(" + request.PackageName + ")", 6,
"No new launcher found in the package (" + request.PackageName + ")");
}
// 主程序:优先用清单里的包名,否则按已知名字挑一个(发布包是整目录,
// 里面同时有 GC-UI.exe / GC.UI.Server.exe / GC-SAVEDOG.exe,不能瞎猜第一个)。
var mainName = Path.GetFileName(artifact);
var mainTarget = Path.Combine(installDir, mainName);
if (_options.DryRun)
{
_log.Info($"[dry-run] 校验全部通过,将整目录安装到 {installDir}" +
$"({Directory.GetFileSystemEntries(stage).Length} 个顶层条目)",
$"[dry-run] All checks passed; would install the whole directory to {installDir} " +
$"({Directory.GetFileSystemEntries(stage).Length} top-level entries)");
ClearDirectory(stage);
return 0;
}
var previous = ReadLastGood(updateDir);
if (previous != null && SameVersion(previous.Version, request.Version) &&
(File.Exists(mainTarget) || Directory.Exists(mainTarget)))
{
// 同一版本重复下发:当成已安装,避免反复覆盖正在运行的文件
_log.Info($"v{request.Version} 已安装且上次启动正常,视为已安装",
$"v{request.Version} is already installed and started fine last time; treating as installed");
ClearDirectory(stage);
TryDelete(zipPath);
TryDelete(requestPath);
WriteState(updateDir, new SavedogState
{
Status = "applied",
Version = request.Version,
PackageName = mainName,
Verified = true,
Message = "目标版本已存在,无需替换"
});
return 0;
}
// 6. 整目录替换:旧内容先搬到 backup,新内容就位;失败可原样还原。
// 只动程序文件,.GC(模型库 / 设置 / 更新目录)永远不碰。
var replaced = new List<(string Name, string? BackupPath)>();
if (!ReplaceInstallDirectory(stage, installDir, updateDir, replaced, out var replaceError))
{
RestoreFromBackup(installDir, replaced);
ClearDirectory(stage);
return Fail(updateDir, "安装失败: " + replaceError, 7, "Installation failed: " + replaceError);
}
_log.Info($"新版已就位:{mainName}(替换 {replaced.Count} 个条目)",
$"New version in place: {mainName} (replaced {replaced.Count} entries)");
// 7. 启动并看护
StartupHealth.Clear(updateDir);
Process? child;
try
{
child = Launch(mainTarget);
}
catch (Exception ex)
{
child = null;
_log.Error("启动新版失败: " + ex.Message,
"Failed to start the new version: " + ex.Message);
}
var healthy = child != null && WaitForHealth(updateDir, request.Version, child,
TimeSpan.FromSeconds(_options.TimeoutSeconds));
if (healthy)
{
_log.Info($"v{request.Version} 启动正常,更新完成",
$"v{request.Version} started successfully; update complete");
CleanupBackup(updateDir);
WriteLastGood(updateDir, request.Version, mainName);
WriteState(updateDir, new SavedogState
{
Status = "applied",
Version = request.Version,
PreviousVersion = previous?.Version,
PackageName = mainName,
Verified = true,
Message = "更新已应用"
});
ClearDirectory(stage);
TryDelete(zipPath);
TryDelete(requestPath);
return 0;
}
// 8. 回滚:撤掉新装的文件,把备份原样搬回
_log.Error($"v{request.Version} 启动后未通过健康检查({_options.TimeoutSeconds}s),开始回滚",
$"v{request.Version} did not pass the health check after {_options.TimeoutSeconds}s; rolling back");
TryKill(child);
var restored = RestoreFromBackup(installDir, replaced);
_log.Info(restored ? "已还原为更新前的文件" : "部分文件未能还原,请手动重新安装",
restored ? "Restored the pre-update files" : "Some files could not be restored; please reinstall manually");
var relaunched = restored && TryLaunchPrevious(installDir, updateDir, previous, request.PlatformLabel);
WriteState(updateDir, new SavedogState
{
Status = "rolledback",
Version = request.Version,
PreviousVersion = previous?.Version,
PackageName = mainName,
Verified = true,
Message = relaunched
? "新版本未通过启动检查,已回滚到上一个版本"
: "新版本未通过启动检查,已移除;未找到可回滚的旧版本,请手动重新安装"
});
ClearDirectory(stage);
TryDelete(zipPath);
TryDelete(requestPath);
return 8;
}
// ------------------------------------------------------------------ 校验辅助
/// <summary>
/// 包名合法性:只允许「一个文件名」,杜绝 `../` 之类的路径穿越。
///
/// 不能只认 .app / .exe —— Linux 的启动器没有扩展名
/// (GC-1.0.9-linux-amd64),按旧规则会被直接判成非法包名、更新永远失败。
/// </summary>
private static bool ValidName(string name)
=> SafeNamePattern.IsMatch(name);
private static readonly Regex SafeNamePattern = new(
@"^[A-Za-z0-9][A-Za-z0-9._-]{0,198}$",
RegexOptions.CultureInvariant | RegexOptions.Compiled);
private static bool WaitForExit(int pid, TimeSpan timeout)
{
var deadline = DateTime.UtcNow + timeout;
while (DateTime.UtcNow < deadline)
{
try
{
using var process = Process.GetProcessById(pid);
if (process.HasExited) return true;
}
catch (ArgumentException) { return true; } // 进程已不存在
catch { return true; }
Thread.Sleep(200);
}
return false;
}
private static void FlattenSingleDirectory(string stage)
{
var entries = Directory.GetFileSystemEntries(stage);
if (entries.Length != 1 || !Directory.Exists(entries[0])) return;
var inner = entries[0];
if (Path.GetFileName(inner).EndsWith(".app", StringComparison.OrdinalIgnoreCase)) return;
var temp = stage + "-flat";
if (Directory.Exists(temp)) Directory.Delete(temp, true);
Directory.Move(inner, temp);
Directory.Delete(stage, true);
Directory.Move(temp, stage);
}
/// <summary>
/// 在解压结果里找主程序。
///
/// 发布包是「整目录」结构(exe + dll + data/),同一层可能有好几个 exe
/// (GC-UI / GC.UI.Server / GC-SAVEDOG / createdump),必须按固定优先级挑,
/// 不能取第一个 —— 否则会把守护进程或调试辅助程序当成启动器拉起来。
/// </summary>
private static string? FindArtifact(string stage, string packageName)
{
if (!string.IsNullOrWhiteSpace(packageName))
{
var named = Path.Combine(stage, packageName);
if (File.Exists(named) || Directory.Exists(named)) return named;
}
var entries = Directory.GetFileSystemEntries(stage);
var byName = entries
.Where(e => File.Exists(e))
.OrderByDescending(e => MainExecutablePriority(Path.GetFileName(e)))
.ThenBy(e => Path.GetFileName(e), StringComparer.OrdinalIgnoreCase)
.ToList();
var best = byName.FirstOrDefault(e => MainExecutablePriority(Path.GetFileName(e)) > 0);
if (best != null) return best;
// macOS:.app 目录本身就是「可执行单元」
foreach (var entry in entries)
{
if (Directory.Exists(entry) &&
Path.GetFileName(entry).EndsWith(".app", StringComparison.OrdinalIgnoreCase))
return entry;
}
return null;
}
/// <summary>主程序优先级:数字越大越优先,0 表示不是主程序。</summary>
private static int MainExecutablePriority(string fileName)
{
if (!fileName.EndsWith(".exe", StringComparison.OrdinalIgnoreCase)) return 0;
// 发布包把启动器改名成 GCL-<版本>-<系统>-<架构>.exe(旧包是 GC-),先按这个模式认出来。
if (VersionedExePattern.IsMatch(fileName)) return 110;
var name = Path.GetFileNameWithoutExtension(fileName);
return name switch
{
"GC-UI" => 100,
"GC" => 90,
"GC.UI.Server" => 80,
// 守护进程 / 调试辅助 / 运行时工具:永远不当主程序
"GC-SAVEDOG" => 0,
"createdump" => 0,
"singlefilehost" => 0,
_ => 10
};
}
// ------------------------------------------------------------------ 启动与看护
private Process? Launch(string target)
{
if (Directory.Exists(target))
{
// .app:优先直接启动内部可执行文件,这样才能拿到 pid 做看护
var macOs = Path.Combine(target, "Contents", "MacOS");
if (Directory.Exists(macOs))
{
var exe = Directory.GetFiles(macOs)
.OrderByDescending(f => Path.GetFileName(f) == "GC")
.FirstOrDefault();
if (exe != null)
{
MakeExecutable(exe);
return StartProcess(exe, Path.GetDirectoryName(exe)!);
}
}
MakeExecutable(Path.Combine(target, "Contents", "MacOS", "GC"));
var psi = new ProcessStartInfo("open") { UseShellExecute = false };
psi.ArgumentList.Add("-n");
psi.ArgumentList.Add(target);
return Process.Start(psi);
}
if (OperatingSystem.IsWindows() || OperatingSystem.IsLinux() || OperatingSystem.IsMacOS())
{
if (!OperatingSystem.IsWindows()) MakeExecutable(target);
return StartProcess(target, Path.GetDirectoryName(target)!);
}
return null;
}
private static Process? StartProcess(string exe, string workingDirectory)
{
var psi = new ProcessStartInfo(exe)
{
UseShellExecute = false,
WorkingDirectory = workingDirectory
};
return Process.Start(psi);
}
private static void MakeExecutable(string path)
{
if (OperatingSystem.IsWindows()) return;
try
{
if (!File.Exists(path)) return;
var mode = File.GetUnixFileMode(path);
File.SetUnixFileMode(path, mode | UnixFileMode.UserExecute |
UnixFileMode.GroupExecute |
UnixFileMode.OtherExecute);
}
catch { }
}
private bool WaitForHealth(string updateDir, string version, Process child, TimeSpan timeout)
{
var deadline = DateTime.UtcNow + timeout;
while (DateTime.UtcNow < deadline)
{
var health = StartupHealth.Read(updateDir);
if (health != null && health.Ok && SameVersion(health.Version, version))
{
_log.Info($"收到健康标记(pid {health.Pid})", $"Health marker received (pid {health.Pid})");
return true;
}
if (child.HasExited)
{
_log.Error($"新版进程已退出(退出码 {child.ExitCode})",
$"The new process exited (code {child.ExitCode})");
return false;
}
Thread.Sleep(250);
}
// 超时但进程还活着:可能是尚未写入健康标记的旧构建,谨慎放行
if (!child.HasExited)
{
_log.Warn("未收到健康标记,但进程仍在运行,按成功处理",
"No health marker, but the process is still running; treating as success");
return true;
}
return false;
}
private static bool SameVersion(string a, string b)
=> string.Equals(Normalize(a), Normalize(b), StringComparison.OrdinalIgnoreCase);
private static string Normalize(string version)
{
var trimmed = version.Trim().TrimStart('v', 'V');
var parts = trimmed.Split('.');
var numbers = new List<string>();
foreach (var part in parts)
{
if (!int.TryParse(part, out var n)) break;
numbers.Add(n.ToString());
}
while (numbers.Count > 0 && numbers[^1] == "0") numbers.RemoveAt(numbers.Count - 1);
return numbers.Count == 0 ? trimmed : string.Join('.', numbers);
}
private static void TryKill(Process? process)
{
if (process == null) return;
try
{
if (!process.HasExited) process.Kill(entireProcessTree: true);
}
catch { }
}
// ------------------------------------------------------------------ 整目录安装 / 回滚
/// <summary>
/// 把 <paramref name="stage"/> 的内容替换进 <paramref name="installDir"/>。
///
/// 发布包是「整目录」(启动器 + 后端运行时 + Flutter 前端资源),只搬一个 exe 会留下
/// 旧后端 / 旧界面,所以这里按目录整体替换:
/// 1. 安装目录里「新版没有」的条目 → 移到 backup(旧版本残留,如上一版的旧文件名);
/// 2. 与新版同名的条目 → 先移到 backup,再把新版放进来(覆盖正在被占用的文件会失败,
/// 这种情况直接报错并还原,绝不留下半新半旧的目录);
/// 3. `.GC` 只合并 `bin/`(非本体文件),其余子目录与更新目录自身一律跳过。
///
/// 返回 false 时调用方应调用 <see cref="RestoreFromBackup"/> 还原。
/// </summary>
private bool ReplaceInstallDirectory(string stage, string installDir, string updateDir,
List<(string Name, string? BackupPath)> replaced, out string? error)
{
error = null;
var backupDir = Path.Combine(updateDir, "backup");
try
{
Directory.CreateDirectory(installDir);
ClearDirectory(backupDir);
Directory.CreateDirectory(backupDir);
var incoming = new List<string>();
foreach (var entry in Directory.GetFileSystemEntries(stage))
{
var name = Path.GetFileName(entry);
if (string.Equals(name, ".GC", StringComparison.OrdinalIgnoreCase))
{
// .GC 里只有 bin/ 属于程序本体(守护进程这类「非本体」文件),
// 其余(config / model / cache / update / logs / safedog)是用户数据,
// 整目录替换时必须原地不动。
MergeGcBin(entry, installDir, backupDir, replaced);
continue;
}
if (IsProtected(name))
{
// 例如 GC-SAVEDOG.exe:本进程正在运行,Windows 上无法替换。
// 保留旧版守护进程即可,它下次启动会随包里的新版本一起被更新。
_log.Warn($"跳过受保护文件,保留旧版本:{name}",
$"Skipping protected file, keeping the old one: {name}");
continue;
}
incoming.Add(entry);
}
var incomingNames = new HashSet<string>(
incoming.Select(e => Path.GetFileName(e)), StringComparer.OrdinalIgnoreCase);
// 1. 旧版独有的条目先清走(保留在 backup 里以便回滚)
foreach (var entry in Directory.GetFileSystemEntries(installDir))
{
var name = Path.GetFileName(entry);
if (incomingNames.Contains(name)) continue;
if (IsProtected(name)) continue;
if (IsSameOrInside(entry, updateDir)) continue;
var target = Path.Combine(backupDir, name);
MoveEntry(entry, target);
replaced.Add((name, target));
_log.Info("旧版残留已备份: " + name, "Old leftover backed up: " + name);
}
// 2. 同名条目:旧 → backup,新 → 安装目录
foreach (var entry in incoming)
{
var name = Path.GetFileName(entry);
var target = Path.Combine(installDir, name);
var backup = Path.Combine(backupDir, name);
if (File.Exists(target) || Directory.Exists(target))
{
MoveEntry(target, backup);
replaced.Add((name, backup));
}
else
{
// 纯新增:回滚时直接删掉,没有备份可还原
replaced.Add((name, null));
}
MoveEntry(entry, target);
}
return true;
}
catch (Exception ex)
{
error = ex.Message;
return false;
}
}
/// <summary>
/// 合并新包里的 <c>.GC/bin</c>:只搬这一层文件,不动 .GC 下的用户数据。
///
/// 守护进程放在这里(而不是安装目录根)是为了「非本体文件全部收进 .GC/bin」;
/// 但正在运行的是 <c>.GC/safedog</c> 里的副本,所以这里的文件可以安全替换。
/// </summary>
private void MergeGcBin(string stageGc, string installDir, string backupDir,
List<(string Name, string? BackupPath)> replaced)
{
try
{
var bin = Path.Combine(stageGc, "bin");
if (!Directory.Exists(bin)) return;
var relBin = Path.Combine(".GC", "bin");
var targetBin = Path.Combine(installDir, relBin);
Directory.CreateDirectory(targetBin);
foreach (var file in Directory.GetFiles(bin))
{
var name = Path.GetFileName(file);
var rel = Path.Combine(relBin, name);
var target = Path.Combine(targetBin, name);
var backup = Path.Combine(backupDir, ".GC-bin", name);
if (File.Exists(target))
{
MoveEntry(target, backup);
replaced.Add((rel, backup));
}
else
{
replaced.Add((rel, null));
}
MoveEntry(file, target);
_log.Info("已更新非本体文件: " + rel, "Updated non-core file: " + rel);
}
}
catch (Exception ex)
{
_log.Warn($"合并 .GC/bin 失败(继续使用已有版本):{ex.Message}",
$"Failed to merge .GC/bin (keeping the existing one): {ex.Message}");
}
}
/// <summary>
/// 把备份里的条目原样搬回安装目录,撤掉新装的内容。
/// <paramref name="BackupPath"/> 为 null 表示这一项是新包里独有的(没有旧版本),
/// 回滚时只需要删掉。
/// </summary>
private bool RestoreFromBackup(string installDir, List<(string Name, string? BackupPath)> replaced)
{
var ok = true;
foreach (var (name, backup) in replaced)
{
var target = Path.Combine(installDir, name);
try
{
// 先撤掉新版(新包里独有的文件也要删干净,否则回滚后目录里新旧混杂)
DeleteEntry(target);
if (string.IsNullOrWhiteSpace(backup) ||
(!File.Exists(backup) && !Directory.Exists(backup)))
continue;
MoveEntry(backup, target);
_log.Info("已还原: " + name, "Restored: " + name);
}
catch (Exception ex)
{
ok = false;
_log.Warn($"还原 {name} 失败: {ex.Message}", $"Failed to restore {name}: {ex.Message}");
}
}
return ok;
}
/// <summary>更新成功:删掉整份备份,不再占用磁盘。</summary>
private void CleanupBackup(string updateDir)
{
var backupDir = Path.Combine(updateDir, "backup");
try
{
if (Directory.Exists(backupDir)) Directory.Delete(backupDir, true);
}
catch (Exception ex)
{
_log.Warn("清理备份失败: " + ex.Message, "Failed to clean up the backup: " + ex.Message);
}
}
/// <summary>
/// 安装目录里不该被更新碰的东西:
/// · .GC —— 模型库、设置、日志、更新目录本身都在这里(只有 bin/ 由 MergeGcBin 单独处理);
/// · GC-SAVEDOG.exe —— 本进程正在运行,Windows 上无法替换。
/// </summary>
private static bool IsProtected(string name)
{
if (string.Equals(name, ".GC", StringComparison.OrdinalIgnoreCase)) return true;
var self = Environment.ProcessPath;
if (!string.IsNullOrWhiteSpace(self) &&
string.Equals(name, Path.GetFileName(self!), StringComparison.OrdinalIgnoreCase))
return true;
return string.Equals(name, "backup", StringComparison.OrdinalIgnoreCase);
}
private static bool IsSameOrInside(string path, string root)
{
try
{
var full = Path.GetFullPath(path).TrimEnd(Path.DirectorySeparatorChar);
var rootFull = Path.GetFullPath(root).TrimEnd(Path.DirectorySeparatorChar);
return full.Equals(rootFull, StringComparison.OrdinalIgnoreCase) ||
full.StartsWith(rootFull + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase);
}
catch { return false; }
}
/// <summary>移动条目;跨卷或目标占用时退回「复制 + 删除」。</summary>
private static void MoveEntry(string from, string to)
{
var parent = Path.GetDirectoryName(to);
if (!string.IsNullOrWhiteSpace(parent)) Directory.CreateDirectory(parent);
if (Directory.Exists(from))
{
Directory.Move(from, to);
return;
}
try
{
File.Move(from, to, overwrite: true);
}
catch (IOException)
{
File.Copy(from, to, overwrite: true);
File.Delete(from);
}
}
/// <summary>删除文件或目录,失败时抛出(由调用方决定是否回滚)。</summary>
private static void DeleteEntry(string path)
{
if (Directory.Exists(path)) Directory.Delete(path, true);
else if (File.Exists(path)) File.Delete(path);
}
private bool TryLaunchPrevious(string installDir, string updateDir, LastGoodVersion? lastGood,
string platformLabel)
{
// 优先用上次成功启动的主程序;否则按优先级在安装目录里找
var candidates = new List<string>();
if (lastGood != null && !string.IsNullOrWhiteSpace(lastGood.PackageName))
candidates.Add(Path.Combine(installDir, lastGood.PackageName));
foreach (var entry in Directory.GetFileSystemEntries(installDir))
{
var name = Path.GetFileName(entry);
if (IsProtected(name)) continue;
if (MainExecutablePriority(name) > 0) candidates.Add(entry);
else if (Directory.Exists(entry) &&
name.EndsWith(".app", StringComparison.OrdinalIgnoreCase))
candidates.Add(entry);
}
foreach (var candidate in candidates.Distinct(StringComparer.OrdinalIgnoreCase))
{
if (!File.Exists(candidate) && !Directory.Exists(candidate)) continue;
try
{
Launch(candidate);
_log.Info("已回滚启动: " + Path.GetFileName(candidate),
"Rolled back and started: " + Path.GetFileName(candidate));
return true;
}
catch (Exception ex)
{
_log.Warn($"回滚启动失败 {Path.GetFileName(candidate)}: {ex.Message}",
$"Failed to start rollback candidate {Path.GetFileName(candidate)}: {ex.Message}");
}
}
return false;
}
// ------------------------------------------------------------------ 状态文件
private void WriteState(string updateDir, SavedogState state)
{
try { Json.Write(Path.Combine(updateDir, SavedogFiles.State), state); }
catch (Exception ex) { _log.Warn("写状态失败: " + ex.Message, "Failed to write state: " + ex.Message); }
}
private int Fail(string updateDir, string message, int code, string? messageEn = null)
{
_log.Error(message, messageEn ?? message);
WriteState(updateDir, new SavedogState { Status = "failed", Message = message });
return code;
}
private int Refuse(string updateDir, SavedogRequest request, ManifestVerification verification)
{
WriteState(updateDir, new SavedogState
{
Status = "refused",
Version = request.Version,
PackageName = request.PackageName,
Verified = false,
Message = $"清单验签失败:{verification.Error}"
});
return 2;
}
private static LastGoodVersion? ReadLastGood(string updateDir)
=> Json.Read<LastGoodVersion>(Path.Combine(updateDir, SavedogFiles.LastGood));
private static void WriteLastGood(string updateDir, string version, string packageName)
{
try
{
Json.Write(Path.Combine(updateDir, SavedogFiles.LastGood), new LastGoodVersion
{
Version = version,
PackageName = packageName
});
}
catch { }
}
private static void ClearDirectory(string dir)
{
try
{
if (Directory.Exists(dir)) Directory.Delete(dir, true);
}
catch { }
}
private static void TryDelete(string path)
{
try { if (File.Exists(path)) File.Delete(path); } catch { }
}
}
-54
View File
@@ -1,54 +0,0 @@
<Project Sdk="Microsoft.NET.Sdk">
<!--
GC-SAVEDOG —— 启动器更新守护进程。
为什么不把替换逻辑留在启动器里:
· 启动器正在运行,Windows 上无法覆盖自己的 exe;
· 覆盖失败(断电 / 占用 / 权限)时启动器已经退出,没人能回滚;
· 更新逻辑需要访问私钥验签,放在独立的最小进程里更容易审计。
本进程只做四件事:验签 → 校验 → 替换 → 看护(不健康就回滚)。
它不引用 Avalonia,也不引用启动器程序集,源码里只链接 GC/src/Security/ 下的
安全原语,保证「校验逻辑与启动器完全同一份实现」。
-->
<PropertyGroup>
<OutputType>Exe</OutputType>
<Nullable>enable</Nullable>
<RootNamespace>GC.Savedog</RootNamespace>
<AssemblyName>GC-SAVEDOG</AssemblyName>
<InvariantGlobalization>true</InvariantGlobalization>
<!--
裁剪发布:自包含单文件不裁剪约 70MB,裁剪后 14MB 左右。
守护进程要跟着更新包一起下发,体积直接影响下载与校验时间。
裁剪的前提是**不用运行时反射**:JSON 全部走 SavedogJsonContext 的源生成类型信息
(见 SavedogJson.cs)。若给这里新加类型却忘了注册,未裁剪的调试构建看不出来,
只有发布产物会在运行时报 NotSupportedException —— 测试用例里有一次真实 apply,
会覆盖到。
-->
<PublishTrimmed>true</PublishTrimmed>
<TrimMode>full</TrimMode>
<JsonSerializerIsReflectionEnabledByDefault>false</JsonSerializerIsReflectionEnabledByDefault>
<!-- 只保留必要的卫星资源,裁剪后再压一层体积 -->
<SatelliteResourceLanguages>en</SatelliteResourceLanguages>
<DebugType>none</DebugType>
</PropertyGroup>
<ItemGroup>
<!-- 应用器测试要直接构造 Applier(internal):只对测试程序集放开可见性 -->
<InternalsVisibleTo Include="GC.Savedog.Tests" />
</ItemGroup>
<ItemGroup>
<!-- 与启动器共用同一份安全实现,避免两套逻辑各说各话。
ManifestLoader 依赖启动器的 RepoVersion 模型,守护进程不需要,排除。 -->
<Compile Include="..\GC\src\Security\**\*.cs" Exclude="..\GC\src\Security\ManifestLoader.cs" LinkBase="Security" />
<Compile Include="..\GC\src\Services\Json.cs" Link="Shared\Json.cs" />
<!-- 与启动器共用同一份双语日志实现,保证 .GC/logs 里格式一致 -->
<Compile Include="..\GC\src\Services\GcLog.cs" Link="Shared\GcLog.cs" />
</ItemGroup>
</Project>
-22
View File
@@ -1,22 +0,0 @@
using System;
using GC.Services;
namespace GC.Savedog;
/// <summary>
/// 守护进程的日志入口,实际写入 <see cref="GcLog"/>:控制台 + <c>.GC/logs</c> 下的
/// <c>gc-YYYYMMDD.log</c>(中文)与 <c>gc-YYYYMMDD.en.log</c>(英文)。
///
/// 每条日志都必须同时给中英两份文案 —— 用户反馈问题时直接发对应语言的文件。
/// </summary>
internal sealed class Log
{
public Log(string? dir)
{
if (!string.IsNullOrWhiteSpace(dir)) GcLog.Init(dir);
}
public void Info(string zh, string en) => GcLog.Info(zh, en);
public void Warn(string zh, string en) => GcLog.Warn(zh, en);
public void Error(string zh, string en) => GcLog.Error(zh, en);
}
-350
View File
@@ -1,350 +0,0 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Text.Json;
using GC.Services;
namespace GC.Savedog;
/// <summary>
/// GC-SAVEDOG 命令行。
///
/// GC-SAVEDOG apply --update &lt;.GC/update&gt; [--install &lt;dir&gt;] [--wait-pid N]
/// [--timeout 45] [--dry-run] [--json]
/// GC-SAVEDOG verify --manifest &lt;version.json&gt; [--require 1] [--json]
/// GC-SAVEDOG verify-model --dir &lt;model/&lt;id&gt;&gt; --id &lt;id&gt; [--json]
/// GC-SAVEDOG keygen [--out .signing] [--key-id gc-2026-11]
/// GC-SAVEDOG sign --manifest &lt;version.json&gt; [--key .signing/gc-signing.pem]
/// [--key-id ...] [--out &lt;file&gt;]
/// GC-SAVEDOG status --update &lt;.GC/update&gt; [--json]
/// </summary>
internal static class Program
{
private const string DefaultKeyId = "gc-2026-12";
private const string DefaultKeyPath = ".signing/gc-signing.pem";
private static int Main(string[] args)
{
try { Console.OutputEncoding = Encoding.UTF8; } catch { }
// 必须在任何 Json.Read/Write 之前接上源生成上下文(裁剪构建必需)
SavedogJson.Initialize();
if (args.Length == 0 || args[0] is "-h" or "--help" or "help")
{
Help();
return 0;
}
var command = args[0].ToLowerInvariant();
var rest = args.Skip(1).ToArray();
var options = Parse(rest);
return command switch
{
"apply" => Apply(options),
"verify" => Verify(options),
"verify-model" => VerifyModel(options),
"keygen" => Keygen(options),
"sign" => Sign(options),
"status" => Status(options),
"version" or "--version" => PrintVersion(),
_ => Unknown(command)
};
}
// ------------------------------------------------------------------ apply
private static int Apply(Dictionary<string, string> options)
{
var updateDir = Option(options, "update", "");
if (string.IsNullOrWhiteSpace(updateDir))
{
Console.Error.WriteLine("apply 需要 --update <.GC/update>");
return 3;
}
// 日志统一放 .GC/logs(update 目录的上一层),不再塞在 update/ 里
var updateRoot = Path.GetFullPath(updateDir);
var home = Path.GetDirectoryName(updateRoot) ?? updateRoot;
var log = new Log(Path.Combine(home, "logs"));
var applyOptions = new ApplyOptions
{
UpdateDir = updateDir,
InstallDir = Option(options, "install", null),
WaitPid = Int(options, "wait-pid", 0),
TimeoutSeconds = Int(options, "timeout", 45),
DryRun = Flag(options, "dry-run"),
Force = Flag(options, "force"),
RequireSignature = Int(options, "require-signature", 1) != 0
};
var applier = new Applier(applyOptions, log);
var code = applier.Run();
if (Flag(options, "json"))
{
if (applyOptions.DryRun)
{
// dry-run 不落盘,state.json 里是上一次的真实结果,直接打印会误导调用方
var request = Json.Read<SavedogRequest>(
Path.Combine(Path.GetFullPath(updateDir), SavedogFiles.ApplyRequest));
Console.WriteLine(Json.Serialize(new SavedogState
{
Status = code == 0 ? "checked" : "failed",
Version = request?.Version ?? "",
PackageName = request?.PackageName ?? "",
Verified = code == 0,
Message = code == 0 ? "校验全部通过(未安装,dry-run)" : "校验未通过(dry-run)"
}));
}
else
{
var state = Json.Read<SavedogState>(
Path.Combine(Path.GetFullPath(updateDir), SavedogFiles.State));
Console.WriteLine(Json.Serialize(state));
}
}
return code;
}
// ------------------------------------------------------------------ verify
private static int Verify(Dictionary<string, string> options)
{
var manifest = Option(options, "manifest", "");
if (string.IsNullOrWhiteSpace(manifest) || !File.Exists(manifest))
{
Console.Error.WriteLine("verify 需要 --manifest <version.json>");
return 3;
}
var require = Int(options, "require", 1) != 0;
var text = File.ReadAllText(manifest);
var result = ManifestSignature.Verify(text, require);
if (Flag(options, "json"))
{
var report = new VerifyReport
{
Trust = result.Trust.ToString(),
KeyId = result.KeyId,
Error = result.Error
};
foreach (var key in SignatureKeyring.Keys)
report.TrustedKeys.Add(new TrustedKey
{
KeyId = key.KeyId,
Fingerprint = ManifestSignature.PublicKeyFingerprint(key.PublicKeyBase64)
});
Console.WriteLine(Json.Serialize(report));
}
else
{
Console.WriteLine($"信任状态: {result.Trust}");
if (result.KeyId != null) Console.WriteLine($"密钥: {result.KeyId}");
if (result.Error != null) Console.WriteLine($"说明: {result.Error}");
foreach (var key in SignatureKeyring.Keys)
Console.WriteLine($"受信任公钥: {key.KeyId} ({ManifestSignature.PublicKeyFingerprint(key.PublicKeyBase64)})");
}
return result.IsTrusted ? 0 : 2;
}
private static int VerifyModel(Dictionary<string, string> options)
{
var dir = Option(options, "dir", "");
var id = Option(options, "id", "");
if (string.IsNullOrWhiteSpace(dir) || string.IsNullOrWhiteSpace(id))
{
Console.Error.WriteLine("verify-model 需要 --dir <model 目录> --id <模型 id>");
return 3;
}
var result = ModelIntegrity.VerifyForLoad(Path.GetFullPath(dir), id);
if (Flag(options, "json"))
Console.WriteLine(Json.Serialize(new VerifyModelReport
{
Ok = result.Ok,
Present = result.Present,
Message = result.Message
}));
else
Console.WriteLine($"{(result.Ok ? "OK" : "FAIL")} 记录={(result.Present ? "有" : "无")} {result.Message}");
return result.Ok ? 0 : 2;
}
// ------------------------------------------------------------------ keygen / sign
private static int Keygen(Dictionary<string, string> options)
{
var outDir = Option(options, "out", ".signing")!;
var keyId = Option(options, "key-id", DefaultKeyId)!;
Directory.CreateDirectory(outDir);
using var key = ECDsa.Create(ECCurve.NamedCurves.nistP256);
var privatePath = Path.Combine(outDir, "gc-signing.pem");
var publicPath = Path.Combine(outDir, "gc-signing.pub");
File.WriteAllText(privatePath, key.ExportPkcs8PrivateKeyPem());
var publicBase64 = ManifestSignature.ExportPublicKeyBase64(key);
File.WriteAllText(publicPath, publicBase64 + "\n");
try
{
if (!OperatingSystem.IsWindows())
File.SetUnixFileMode(privatePath, UnixFileMode.UserRead | UnixFileMode.UserWrite);
}
catch { }
Console.WriteLine("已生成 ECDSA P-256 密钥对:");
Console.WriteLine(" 私钥(绝不要提交): " + privatePath);
Console.WriteLine(" 公钥(写进源码) : " + publicPath);
Console.WriteLine(" keyId : " + keyId);
Console.WriteLine(" 公钥 Base64 : " + publicBase64);
Console.WriteLine(" 公钥指纹 : " + ManifestSignature.PublicKeyFingerprint(publicBase64));
Console.WriteLine();
Console.WriteLine("把下面一行加进 GC/src/Security/SignatureKeyring.cs 的 Keys 列表:");
Console.WriteLine($" new KeyEntry(\"{keyId}\", \"{publicBase64}\"),");
return 0;
}
private static int Sign(Dictionary<string, string> options)
{
var manifest = Option(options, "manifest", "");
var keyPath = Option(options, "key", DefaultKeyPath)!;
var keyId = Option(options, "key-id",
Environment.GetEnvironmentVariable("GC_SIGNING_KEY_ID") ?? DefaultKeyId)!;
if (string.IsNullOrWhiteSpace(manifest) || !File.Exists(manifest))
{
Console.Error.WriteLine("sign 需要 --manifest <version.json>");
return 3;
}
using var key = ManifestSignature.TryLoadPrivateKey(keyPath);
if (key == null)
{
Console.Error.WriteLine($"找不到可用的签名私钥: {Path.GetFullPath(keyPath)}");
return 4;
}
var text = File.ReadAllText(manifest);
var signed = ManifestSignature.SignDocument(text, key, keyId);
var output = Option(options, "out", manifest)!;
File.WriteAllText(output, signed);
var check = ManifestSignature.Verify(signed, requireSignature: true);
Console.WriteLine($"已签名: {output}({check.Trust})");
return check.Trust == ManifestTrust.Verified ? 0 : 5;
}
// ------------------------------------------------------------------ status
private static int Status(Dictionary<string, string> options)
{
var updateDir = Path.GetFullPath(Option(options, "update", ".GC/update")!);
var state = Json.Read<SavedogState>(Path.Combine(updateDir, SavedogFiles.State));
var lastGood = Json.Read<LastGoodVersion>(Path.Combine(updateDir, SavedogFiles.LastGood));
var health = StartupHealth.Read(updateDir);
if (Flag(options, "json"))
{
Console.WriteLine(Json.Serialize(new StatusReport
{
State = state,
LastGood = lastGood,
Health = health
}));
return 0;
}
Console.WriteLine(state == null
? "没有更新记录"
: $"最近更新: {state.Status} v{state.Version} -> {state.Message}({state.At})");
Console.WriteLine(lastGood == null
? "上次成功版本: 未知"
: $"上次成功版本: v{lastGood.Version}({lastGood.PackageName})");
Console.WriteLine(health == null
? "健康标记: 无"
: $"健康标记: v{health.Version} pid={health.Pid} ok={health.Ok}");
return 0;
}
private static int PrintVersion()
{
Console.WriteLine("GC-SAVEDOG 1.0.0");
Console.WriteLine("签名算法: " + ManifestSignature.Algorithm);
return 0;
}
private static int Unknown(string command)
{
Console.Error.WriteLine($"未知命令: {command}");
Help();
return 3;
}
private static void Help()
{
Console.WriteLine("""
GC-SAVEDOG —— 启动器更新守护进程
apply --update <.GC/update> [--install <dir>] [--wait-pid N]
[--timeout 45] [--dry-run] [--force] [--json]
verify --manifest <version.json> [--require 1] [--json]
verify-model --dir <model/ID> --id <ID> [--json]
keygen [--out .signing] [--key-id gc-2026-11]
sign --manifest <version.json> [--key .signing/gc-signing.pem] [--out <file>]
status --update <.GC/update> [--json]
退出码:0 成功 / 2 验签失败(拒绝) / 3 参数或申请错误 / 5 包校验失败 / 8 已回滚
""");
}
// ------------------------------------------------------------------ 参数
private static Dictionary<string, string> Parse(string[] args)
{
var map = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
for (var i = 0; i < args.Length; i++)
{
var arg = args[i];
if (!arg.StartsWith("--", StringComparison.Ordinal))
{
map[arg] = "1";
continue;
}
var name = arg[2..];
var eq = name.IndexOf('=');
if (eq > 0)
{
map[name[..eq]] = name[(eq + 1)..];
continue;
}
if (i + 1 < args.Length && !args[i + 1].StartsWith("--", StringComparison.Ordinal))
{
map[name] = args[++i];
continue;
}
map[name] = "1";
}
return map;
}
private static string? Option(Dictionary<string, string> options, string name, string? fallback)
=> options.TryGetValue(name, out var value) ? value : fallback;
private static int Int(Dictionary<string, string> options, string name, int fallback)
=> options.TryGetValue(name, out var value) && int.TryParse(value, out var parsed)
? parsed : fallback;
private static bool Flag(Dictionary<string, string> options, string name)
=> options.TryGetValue(name, out var value) &&
(value == "1" || value.Equals("true", StringComparison.OrdinalIgnoreCase));
}
-79
View File
@@ -1,79 +0,0 @@
using System;
using System.Collections.Generic;
using System.Text.Json;
using System.Text.Json.Serialization;
using GC.Services;
namespace GC.Savedog;
/// <summary>
/// GC-SAVEDOG 是裁剪发布的(PublishTrimmed),反射式序列化在裁剪后会失效:
/// trimmer 认为「没人 new 过」的构造函数会被删掉,运行时反序列化直接抛
/// <c>NotSupportedException</c>。因此守护进程把所有 JSON 类型都注册进源生成上下文,
/// 编译期生成类型信息,运行时零反射。
///
/// 新增需要读写的 JSON 类型时,记得在这里补一行 <c>[JsonSerializable]</c>,
/// 否则会在裁剪产物里报错(未裁剪的调试构建看不出问题)。
/// </summary>
[JsonSourceGenerationOptions(
PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase,
PropertyNameCaseInsensitive = true,
WriteIndented = true,
DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
AllowTrailingCommas = true,
ReadCommentHandling = JsonCommentHandling.Skip)]
[JsonSerializable(typeof(SavedogRequest))]
[JsonSerializable(typeof(SavedogState))]
[JsonSerializable(typeof(LastGoodVersion))]
[JsonSerializable(typeof(StartupHealth.HealthRecord))]
[JsonSerializable(typeof(ModelIntegrityFile))]
[JsonSerializable(typeof(VerifyReport))]
[JsonSerializable(typeof(StatusReport))]
[JsonSerializable(typeof(VerifyModelReport))]
internal partial class SavedogJsonContext : JsonSerializerContext
{
// 源生成器已提供 (JsonSerializerOptions) 构造函数;实例化时传入启动器的那套选项,
// 让两边写出的 JSON 完全同款(中文不转成 \uXXXX、缩进一致),便于直接 diff 排查。
}
/// <summary><c>verify --json</c> 的输出。</summary>
internal sealed class VerifyReport
{
public string Trust { get; set; } = "";
public string? KeyId { get; set; }
public string? Error { get; set; }
public List<TrustedKey> TrustedKeys { get; set; } = new();
}
internal sealed class TrustedKey
{
public string KeyId { get; set; } = "";
public string Fingerprint { get; set; } = "";
}
/// <summary><c>status --json</c> 的输出。</summary>
internal sealed class StatusReport
{
public SavedogState? State { get; set; }
public LastGoodVersion? LastGood { get; set; }
public StartupHealth.HealthRecord? Health { get; set; }
}
/// <summary><c>verify-model --json</c> 的输出。</summary>
internal sealed class VerifyModelReport
{
public bool Ok { get; set; }
public bool Present { get; set; }
public string Message { get; set; } = "";
}
/// <summary>把共享的 <see cref="Json"/> 接到源生成上下文上。</summary>
internal static class SavedogJson
{
private static readonly SavedogJsonContext Context = new(new JsonSerializerOptions(Json.Options));
public static void Initialize()
{
Json.TypeInfoProvider = type => Context.GetTypeInfo(type);
}
}
-161
View File
@@ -1,161 +0,0 @@
# GC-UI 持续集成
alpha 构建的工作流在 [`.gitea/workflows/gc-ui-alpha.yml`](../.gitea/workflows/gc-ui-alpha.yml),
**只支持手动触发**(定时任务已取消:它绕开 build.sh,产出的包没有后端、没有前端,跑起来只是个空壳;
另外 `cron` 里的 `TZ=` 前缀在部分 Gitea 版本上是非法表达式)。
PR 审核流水线在 [`.gitea/workflows/pr-check.yml`](../.gitea/workflows/pr-check.yml)。
本仓库是自建 Gitea(不是 GitHub),所以目录是 `.gitea/workflows/`,语法与 GitHub Actions 基本一致,
差异集中在 **runner 标签** 和 **API 前缀** 两处。
## 它做什么
| 任务 | 运行环境 | 产出 |
|---|---|---|
| `prepare` | `ubuntu-latest` | 算版本号,建一个 **草稿 + prerelease** 的 Release |
| `windows` | `windows-latest` | `gc-ui-alpha-windows-x64.zip`(Flutter release 目录) |
| `macos` | `macos-latest` | `gc-ui-alpha-macos-<arch>.zip`(`gc_ui.app`,用 `ditto` 打包保真) |
| `publish` | `ubuntu-latest` | 两个平台都成功后才把草稿翻成可见,并断言 latest 没被占用 |
- **定时**:每天 **21:00(Asia/Shanghai)**,cron 写作 `TZ=Asia/Shanghai 0 21 * * *`。
Gitea 1.23 起 Actions 的 cron 默认按 **UTC** 解释,所以这里显式带时区前缀;
若你的实例不认 `TZ=`,改成等效的 UTC 写法 `0 13 * * *`。
- **alpha 不占用 latest**:Gitea 的 `/releases/latest` 只返回「最近一个既非草稿、也非 prerelease」
的发布,所以 `prerelease: true` 的夜间版本永远不会成为 latest。`publish` 任务最后会再查一次
`/releases/latest`,一旦指向本次 tag 就 fail。
- **手动触发**:Actions 页面 Run workflow;或
```bash
curl -X POST -u "USER:TOKEN" \
"https://git.xhmcl.com/api/v1/repos/Morris/GC/actions/workflows/gc-ui-alpha.yml/dispatches" \
-H 'Content-Type: application/json' -d '{"ref":"gc-ui","inputs":{"note":"手动验证"}}'
```
## 前置条件(缺一不可)
### 1. 必须有 act_runner,并且带这三个标签
```bash
# 在准备当构建机的机器上(Windows / macOS 各一台,或一台 Linux 只跑 prepare/publish)
docker run -d --name gitea-runner \
-v /var/run/docker.sock:/var/run/docker.sock \
-v /path/to/runner-data:/data \
-e GITEA_INSTANCE_URL=https://git.xhmcl.com \
-e GITEA_RUNNER_REGISTRATION_TOKEN=<在 站点管理 → Actions → Runners 里拿> \
-e GITEA_RUNNER_LABELS=ubuntu-latest:docker://gitea/runner-images:ubuntu-latest,windows-latest:docker://<你的 windows 镜像>,macos-latest:docker://<你的 macos 镜像> \
gitea/act_runner:latest
```
关键点:**`runs-on` 的值必须和 runner 上注册的 label 完全一致**,否则任务永远排队。
Windows / macOS 的构建**不能**跑在 Linux docker 容器里(一个要 MSVC,一个要 Xcode),
所以那两个 label 需要指向真实的 Windows / macOS 机器(自托管 runner)。
### 2. Flutter SDK
工作流里有一条「准备 Flutter SDK」:机器上已有 `flutter` 就直接用;没有就按
`FLUTTER_VERSION`(默认 3.24.5,需 >= 3.5.4 以匹配 `pubspec.yaml` 的 `sdk: ^3.5.4`)从
`storage.googleapis.com` 下载官方 SDK 并写进 `PATH`。所以机器只要能上外网就够,不必预装。
网络受限时请预装 Flutter 并确保 `flutter` 在 `PATH` 里。
Windows 还需要 **VS Build Tools 的「使用 C++ 的桌面开发」工作负载**;macOS 需要 **Xcode**。
### 3. Token
优先用仓库 Secrets 里的 `RELEASE_TOKEN`(Gitea 设置 → Actions → Secrets,需 `repo` 权限的个人访问令牌);
没配就退回 Gitea 自动注入的 `github.token`。若自动 token 没有 release 权限,
创建 Release 那步会报 401/403 —— 这时配一个 `RELEASE_TOKEN` 即可,不用改工作流文件。
## 本地构建(不经 CI)
```bash
# 按构建主机自动选目标,每条产物都带 Flutter 前端:
# macOS 主机 → mac-arm64(原生)+ win-amd64 / win-arm64(mingw 交叉)
# Linux 主机 → win-amd64 / win-arm64(mingw 交叉)
# Linux 产物默认不出:需 aarch64 主机 + GC_BUILD_LINUX=1
# Windows 主机 → win-amd64 / win-arm64(原生)
./build.sh build
# 前端是必需项:flutter 缺失或编译失败会直接中断,
# 确需降级成只有 Avalonia 回退界面的包时才用:
./build.sh build --allow-no-ui
# 只编 macOS 前端
./GC-UI/build-ui.sh macos
# Windows 主机原生构建
GC-UI\build-ui.cmd
```
### Linux 前端(原生)
Flutter 的 Linux 桌面端只能在 Linux 上编,需要 GTK3 开发库与 C++ 工具链:
```bash
sudo apt install clang cmake ninja-build pkg-config libgtk-3-dev libstdc++-14-dev
```
`libstdc++-14-dev` 容易漏:clang 18 会去 `/usr/lib/gcc/x86_64-linux-gnu/14/` 找
`-lstdc++`,系统只装了 gcc-13 的开发包时链接会失败,报 `cannot find -lstdc++`。
产物布局:`GC-UI` + `lib/libflutter_linux_gtk.so` + `data/`,与官方 `flutter build
linux` 的 bundle 一致,直接铺进 `dist/linux-arm64/`。
### Windows 前端交叉编译
Flutter 官方不支持在非 Windows 主机上 `flutter build windows`,但 Windows 嵌入层
(`windows/runner/*.cpp` + `cpp_client_wrapper`)是纯 Win32 + 标准 C++,只通过 C ABI
调用 `flutter_windows.dll`,所以 mingw-w64 就能编译。整条链路上唯一必须执行的
Windows 二进制是 AOT 快照生成器 `gen_snapshot.exe`,交给 wine 跑即可。
```bash
# 依赖
sudo apt install mingw-w64 cmake ninja-build wine # Linux
brew install mingw-w64 cmake ninja # macOS
brew install --cask wine-stable # macOS 的 wine
# 单独构建(默认输出到 GC-UI/frontend/build/windows/x64/runner/Release)
./buildsh/cross/build-ui-win-cross.sh [输出目录]
```
产物与官方 toolchain 完全一致,可直接拷到 Windows 运行:
```
GC-UI.exe flutter_windows.dll data/{icudtl.dat, app.so, flutter_assets/}
```
实现分三层:
| 文件 | 职责 |
|---|---|
| `buildsh/cross/toolchain-mingw.cmake` | CMake 交叉工具链(posix 线程模型,静态链接 libstdc++,产物只依赖系统 DLL) |
| `buildsh/cross/CMakeLists.txt` | 只编 C++ 外壳;绕开 `tool_backend.bat` 与 MSVC 专用参数 |
| `buildsh/cross/build-ui-win-cross.sh` | 拉引擎产物、装 `gen_snapshot` 的 wine 包装、生成 AOT 快照、组装 |
两个容易踩的坑,脚本里已处理:
- `flutter_tools` 会 exec 路径为 `.../windows-x64-release/gen_snapshot`(**没有 `.exe`**)
的文件,所以脚本在原 `.exe` 旁边放一个同名 shell 脚本转调 wine。
- `Runner.rc` 在 windres 下有两处不兼容:图标用反斜杠相对路径、`VERSION_AS_STRING`
依赖命令行传 `-D` 的转义字符串。脚本生成一份路径与宏都已规整的 rc 副本再编译。
### 交叉编译必须自己嵌 DPI 清单
`windows/runner/CMakeLists.txt` 把 `runner.exe.manifest` 当**源文件**列进 target,
Visual Studio 生成器会把它交给链接器(`/MANIFESTINPUT`)自动嵌入 exe;
但 `buildsh/cross/CMakeLists.txt` 只用 windres 编 `Runner.rc`,CMake 不会做这一步。
结果就是交叉编出来的 `GC-UI.exe` **完全没有清单**:Windows 认为它「DPI 不感知」,
在 125% / 150% 缩放的屏幕上把整块窗口当位图拉伸 —— 界面整体发虚,中文小字最明显。
现在两处都已加固,改这块代码时不要拆掉任何一处:
| 位置 | 做法 |
|---|---|
| `buildsh/cross/CMakeLists.txt` | 往 `Runner.cross.rc` 追加 `1 24 "<abs>/runner.exe.manifest"`(id 1 = CREATEPROCESS_MANIFEST_RESOURCE_ID,type 24 = RT_MANIFEST) |
| `windows/runner/main.cpp` | 建窗之前调 `SetProcessDpiAwarenessContext(PER_MONITOR_AWARE_V2)`,失败依次退到 `SetProcessDpiAwareness` / `SetProcessDPIAware` |
`main.cpp` 那层是兜底:即使清单因为工具链原因没嵌进去,程序自己也会声明 DPI 感知。
验证办法(Windows):`GC-UI.exe` 属性 →「兼容性」里不该出现「替代高 DPI 缩放行为」,
或在 125% 缩放下截图,文字边缘应是锐利的 1.25 倍像素,而不是模糊的插值。
`.gitea/workflows` 里的 `windows` 任务仍然跑在 `windows-latest` 上;若手头只有 macOS/Linux
构建机,可以把该任务的 `runs-on` 换成对应标签,直接复用这套交叉编译脚本,
不再需要 VS Build Tools。
-201
View File
@@ -1,201 +0,0 @@
# GC-UI
GC 启动器的**前后端分离**实现:界面用 Flutter,服务层留在 .NET。
```
GC-UI/
├── backend/GC.UI.Server/ # .NET 8 后端:本地 HTTP API + 模型窗口宿主
│ ├── Program.cs # 所有接口(最小 API)
│ ├── ApiModels.cs # 前后端 JSON 契约
│ └── AvaloniaHost.cs # 模型窗口宿主(Avalonia,惰性启动)
└── frontend/ # Flutter 前端(Windows / macOS 桌面)
├── lib/
│ ├── main.dart # 应用入口
│ ├── shell.dart # 侧边栏 + 内容区 + 更新状态条
│ ├── pages.dart # 首页 / 下载 / 设置 / 关于
│ ├── controller.dart # 外壳状态(设置、健康、更新)
│ ├── api_client.dart # 后端 HTTP 客户端 + DTO
│ ├── i18n.dart # zh-CN / en 文案
│ └── theme.dart # 配色与通用组件
├── windows/ # Windows 原生 runner(flutter create 生成)
├── macos/ # macOS 原生 runner(flutter create 生成)
└── test/ # 单元测试 + 后端契约测试 + 截图脚本
```
## 为什么这样切
原来的 GC 是「Avalonia 界面 + 服务层」一体式应用。拆分时唯一不能动的是**模型契约**:
模型 dll 通过 `IModelRuntime.CreateView` 返回的是 Avalonia `Control`,渲染栈是契约的一部分。
把渲染换成 Flutter 等于让所有已发布模型失效。
所以切法是:
| 层 | 归属 | 说明 |
|---|---|---|
| 首页 / 下载 / 设置 / 关于 | **Flutter 前端** | 纯界面,通过 HTTP 调后端 |
| 模型扫描、下载、更新、设置持久化 | **.NET 后端** | 直接复用 `GC/src`(GC.Core)与 `GC-DOWNLOAD` |
| 模型自己的窗口 | **.NET 后端** | 模型返回 Avalonia 控件,由后端承载 |
前端只发一条「启动模型」的指令,模型窗口由后端在自己的 UI 线程上打开。
## 前端方案:为什么是 Flutter
Windows 与 macOS 用**同一套 Flutter 代码 + 各自的原生 runner**:
- **一套代码两个平台**:`flutter create --platforms=windows,macos` 生成 `windows/`(CMake + Win32 窗口)与 `macos/`(Xcode + Cocoa 窗口)两个原生壳,业务代码 100% 共用。
- **原生桌面窗口**:不是 WebView 套壳,两个平台都是真正的原生窗口,可设置最小尺寸、标题栏、DPI 缩放。
- **渲染一致**:Skia/Impeller 自绘,两个平台像素级一致,不需要为 WinUI / AppKit 各写一套控件。
- **热重载**:`flutter run -d windows` / `-d macos` 改界面即时生效,迭代比 XAML 快。
- **对比过的替代方案**:
- *继续用 Avalonia*:跨平台没问题,但那就不是「前后端分离 + Flutter 前端」了。
- *WinUI 3 + SwiftUI 各写一套*:两套 UI 代码、两套状态管理,维护成本翻倍。
- *Electron / Tauri*:WebView 套壳,包体大(Electron ~150MB)或需要 Rust 工具链,且与 .NET 后端通信仍要额外桥接。
## 运行
### 1. 启动后端
发布版里后端不走独立进程:`GC-BOOT` 直接引用本工程,调用
`BackendServer.Start(args, port)` 在自己进程内托管,发布包因此只有一个 exe
(两个自包含进程会把 60MB 运行时复制两份)。下面的独立运行方式只用于开发调试。
```bash
# 仓库根目录
dotnet run --project GC-UI/backend/GC.UI.Server
# 指定端口(默认 17890)
dotnet run --project GC-UI/backend/GC.UI.Server -- --port 17890
# 或
GC_UI_PORT=17890 dotnet run --project GC-UI/backend/GC.UI.Server
```
端口约定集中在 `GC.Services.GcUiContract`(`DefaultPort` / `PortEnvVar`):
正式启动时由 GC-BOOT 选端口(17890 被占用就往后试 9 个),再通过 `GC_UI_PORT`
环境变量同时传给后端和前端,所以**不需要为了换端口重新编译前端**。
启动后后端会在 `~/.GC/ui-backend.json` 写入 `{ port, pid, url, version, platform }`,
排查问题时可以据此确认实际端口。
### 2. 启动前端
```bash
cd GC-UI/frontend
flutter pub get
# Windows
flutter run -d windows
# macOS
flutter run -d macos
# 后端不在默认端口时
flutter run -d windows --dart-define=GC_UI_BASE_URL=http://127.0.0.1:18000
```
### 3. 打包
```bash
cd GC-UI/frontend
flutter build windows --release # build/windows/x64/runner/Release/
flutter build macos --release # build/macos/Build/Products/Release/
```
或直接用仓库根目录的脚本:
```bash
./GC-UI/build-ui.sh # macOS / Linux 上构建(macOS 产物)
GC-UI\build-ui.cmd # Windows 上构建(Windows 产物)
```
## HTTP 接口
后端只监听 `127.0.0.1`,不对外暴露。
| 方法 | 路径 | 说明 |
|---|---|---|
| GET | `/api/health` | 健康检查 + 模型窗口宿主是否可用 |
| GET | `/api/models` | 已安装模型 |
| GET | `/api/models/{id}/preview` | 模型封面图(PNG) |
| POST | `/api/models/{id}/launch` | 启动模型(打开模型自己的窗口) |
| DELETE | `/api/models/{id}` | 删除模型 |
| GET | `/api/settings` | 读取设置 |
| POST | `/api/settings` | 修改设置(补丁式,只改传入字段) |
| GET | `/api/sources` | 模型源列表 |
| POST | `/api/sources/select` | 双源测速并切到最快 |
| GET | `/api/remote/models?sourceId=&force=` | 远端可下载模型 |
| POST | `/api/download` | 入队下载 `{ sourceId, modelId }` |
| GET | `/api/download/jobs` | 下载任务列表 |
| POST | `/api/download/{id}/cancel` | 取消 |
| POST | `/api/download/{id}/retry` | 重试 |
| POST | `/api/download/{id}/remove` | 移除任务 |
| POST | `/api/download/clear-finished` | 清除已完成 |
| POST | `/api/update/check` | 检查模型 / 启动器更新 |
| GET | `/api/about` | 版本 + 贡献者 |
| POST | `/api/shell/open-folder` | 打开目录(仅限启动器自己的目录) |
| POST | `/api/shell/open-url` | 打开 http/https 链接 |
契约定义见 `backend/GC.UI.Server/ApiModels.cs`,前端对应 `frontend/lib/api_client.dart`。
## 测试
```bash
# 后端编译
dotnet build GC-UI/backend/GC.UI.Server
# 前端静态检查 + 单元测试
cd GC-UI/frontend
flutter analyze
flutter test
# 前后端联调(需要后端正在运行;后端没起时自动跳过)
flutter test test/backend_contract_test.dart
# 生成界面截图到 test/shots/(视觉检查用,不需要后端)
flutter test tool/render_shots_test.dart
```
截图脚本覆盖四个页面(首页 / 下载 / 设置 / 关于),再加一整套外壳与 1024×680 小窗回归:
`test/shots/home.png`、`download.png`、`settings.png`、`about.png`、`shell.png`、
`home-small.png`、`download-small.png`、`settings-small.png`,以及浅色主题的
`home-light.png`、`settings-light.png`。小窗用例会顺带抓布局溢出(RenderFlex overflow)。
四个页面都用预置数据(`initialModels` / `initialSources` / `initialAbout` 等)渲染,
所以**不需要先起后端**。测试环境的字体是 Ahem(所有字都是方块),脚本会显式加载
系统里的 Noto Sans SC / 微软雅黑 / 苹方,并顺带加载 Material 图标字体,中文和图标才正常。
截图必须放在 `runAsync` 里取像素(`toImage` / `toByteData` 走真实引擎管线),
否则 fake async 时钟不推进,每个用例会卡满 10 分钟才超时。
## 界面清晰度(DPI)
`GC-UI.exe` 必须在启动时就声明 DPI 感知,否则 Windows 在 125% / 150% 缩放下会把
整块窗口当位图拉伸,界面看起来「糊」—— 中文小字最先糊。两处保证:
- `windows/runner/runner.exe.manifest`:PerMonitorV2(原生 MSVC 构建由 CMake 自动嵌入)
- `windows/runner/main.cpp`:建窗前再声明一次,依次尝试
`SetProcessDpiAwarenessContext` → `SetProcessDpiAwareness` → `SetProcessDPIAware`
- `buildsh/cross/CMakeLists.txt`:交叉编译时把清单写进 `.rc`(windres 不会自动嵌入)
另外主题里做了两件跟「清晰」有关的事:字体族走
`Segoe UI + Microsoft YaHei UI`(macOS 走苹方)而不是让引擎随意回退;
正文最小 12px、行高固定,中文不再挤成一片。详见
[CI.md 的「交叉编译必须自己嵌 DPI 清单」](CI.md#交叉编译必须自己嵌-dpi-清单)。
## 「关于」页展示的技术栈
「关于」页的版本卡片里直接写明这套实现的两个关键点:
| 行 | 值 | 来源 |
|---|---|---|
| 源码语言 | **C#** | 后端 `/api/about` 返回 `sourceLanguage` |
| 前端 | **Flutter** | 后端 `/api/about` 返回 `frontend` |
| 架构 | Flutter 前端 + .NET 后端(本地 HTTP) | 前端 i18n 文案 |
两个字段由后端下发(而不是前端写死),所以将来换实现时只改后端一处,
前端和「关于」页自动跟着变。契约字段见 `ApiModels.cs` 的 `AboutDto`,
前端解析在 `lib/api_client.dart` 的 `AboutInfo`。
## 安全边界
- 后端只绑定 `127.0.0.1`,不接受外部连接。
- `open-folder` 只允许打开模型库 / 数据目录 / 应用目录之内的路径,避免被当成任意路径执行器。
- `open-url` 只允许 `http` / `https`。
- CORS 只放行 `localhost` / `127.0.0.1` 来源,方便 `flutter run -d chrome` 调试界面。
-152
View File
@@ -1,152 +0,0 @@
using System.Collections.Generic;
namespace GC.UI.Server;
// ---------------------------------------------------------------------------
// 前后端之间的数据契约(HTTP + JSON,camelCase)。
// 前端(Flutter)只认这些字段,不认 .NET 类型;后端换实现不影响前端。
// ---------------------------------------------------------------------------
public sealed record HealthDto(
bool Ok,
string Version,
string Platform,
bool UiAvailable,
string? UiError,
string? SessionProof = null);
public sealed record ModelDto(
string Id,
string Name,
string Description,
string Version,
string Author,
long SizeBytes,
string SizeText,
IReadOnlyList<string> Tags,
bool HasPreview,
string PreviewUrl,
string Directory,
string DataDirectory);
public sealed record SourceDto(
string Id,
string Name,
string Url,
bool Enabled,
bool BuiltIn,
string Host);
public sealed record RemoteModelDto(
string Id,
string Name,
string Description,
string Version,
long SizeBytes,
string SizeText,
string SourceId,
bool Installed,
string? InstalledVersion);
public sealed record SourceIndexDto(
string SourceId,
string Root,
bool FromCache,
string? Error,
string ResolvedFrom,
IReadOnlyList<RemoteModelDto> Models);
public sealed record JobDto(
string Id,
string ModelId,
string Name,
string Version,
string State,
double Progress,
string StatusText,
string DetailText,
string? Error,
bool IsActive,
bool CanRetry,
bool IsDone);
public sealed record LanguageDto(string Code, string Label);
public sealed record SettingsDto(
string Language,
string Theme,
string AccentColor,
int RenderFps,
int MemoryMb,
bool MemoryAuto,
bool AutoUpdateOnStartup,
bool RequireSignedManifest,
string UpdateRepository,
string? UpdateLocalRoot,
string? ModelRootOverride,
int MemoryBudgetMb,
string MemoryUsageText,
string ModelRoot,
string DataRoot,
string SettingsFile,
string Version,
string Platform,
IReadOnlyList<SourceDto> Sources,
IReadOnlyList<LanguageDto> Languages);
/// <summary>设置补丁:只改传进来的字段,null 表示不动。</summary>
public sealed record SettingsPatch(
string? Language,
string? Theme,
string? AccentColor,
int? RenderFps,
int? MemoryMb,
bool? MemoryAuto,
bool? AutoUpdateOnStartup,
bool? RequireSignedManifest,
string? UpdateRepository,
string? UpdateLocalRoot,
string? ModelRootOverride);
public sealed record LatencyDto(string Id, string Name, long Milliseconds);
public sealed record UpdateCheckDto(
string Outcome,
string Message,
int UpdatedModels,
IReadOnlyList<string> ModelNames,
string? LauncherMessage,
string? Error,
string? LauncherLatest,
string SourceName,
IReadOnlyList<LatencyDto> Latency);
public sealed record ContributorDto(string Name, int Contributions, string? AvatarUrl);
public sealed record AboutDto(
string AppName,
string Version,
string Platform,
string Repository,
IReadOnlyList<ContributorDto> Contributors,
string SourceLanguage,
string Frontend);
public sealed record LaunchResultDto(bool Ok, string Message);
/// <summary>
/// 通用错误响应。限流 / 参数校验这类与具体业务无关的失败用它,
/// 不要复用 <see cref="LaunchResultDto"/> —— 那会让前端误以为「启动模型」有结果。
/// </summary>
public sealed record ErrorDto(bool Ok, string Message)
{
public static ErrorDto Of(string message) => new(false, message);
}
public sealed record DownloadRequest(string SourceId, string ModelId);
public sealed record PathRequest(string Path);
public sealed record UrlRequest(string Url);
public sealed record ForceRequest(bool Force);
-180
View File
@@ -1,180 +0,0 @@
using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using Avalonia;
using Avalonia.Controls;
using Avalonia.Controls.ApplicationLifetimes;
using Avalonia.Threading;
using GC.Models;
using GC.Services;
using GC.Views;
namespace GC.UI.Server;
/// <summary>
/// 模型窗口宿主。
///
/// 为什么渲染这一层留在 .NET:模型 dll 通过 <c>IModelRuntime.CreateView</c> 返回的是
/// Avalonia <see cref="Control"/>,这是模型契约的一部分。把渲染栈换成 Flutter 等于换掉契约,
/// 所有已发布模型都会失效。所以前后端分离的切法是:
/// · 界面(首页 / 下载 / 设置 / 关于)→ Flutter 前端
/// · 模型窗口(模型自带界面)→ 仍由 .NET 承载,前端只发一条「启动模型」的指令
///
/// 这里惰性启动一个没有主窗口的 Avalonia 桌面生命周期,之后所有模型窗口都在它的 UI 线程上创建。
/// 无桌面会话(CI / 无头环境)时启动会失败,此时只有「启动模型」不可用,其余接口照常工作。
/// </summary>
public sealed class AvaloniaHost
{
private readonly AppServices _services;
private readonly object _gate = new();
private readonly Dictionary<string, PlayerWindow> _windows = new(StringComparer.OrdinalIgnoreCase);
private readonly TaskCompletionSource<bool> _ready =
new(TaskCreationOptions.RunContinuationsAsynchronously);
private int _started;
public AvaloniaHost(AppServices services) => _services = services;
public bool IsAvailable { get; private set; }
public string? LastError { get; private set; }
/// <summary>
/// 后端线程调用:等待「主线程已把 Avalonia 事件循环跑起来」。
///
/// 关键点:macOS 的 AppKit 要求 NSApplication 在**主线程**。以前这里把
/// <c>StartWithClassicDesktopLifetime</c> 丢到一个新建的后台线程里跑,在 macOS 上
/// 会直接崩掉整个后端进程(表现为点「启动模型」界面无反应、随后后端消失)。
/// 现在改为由启动器在主线程调用 <see cref="RunOnCurrentThread"/>,
/// 这里只等待就绪信号。
/// </summary>
public Task<bool> EnsureStartedAsync() => _ready.Task;
/// <summary>
/// 必须在 UI 主线程调用。启动 Avalonia 桌面生命周期并阻塞,直到 <see cref="Shutdown"/>。
/// 返回后(或初始化失败后)调用方负责收尾。
/// </summary>
public void RunOnCurrentThread()
{
if (Interlocked.Exchange(ref _started, 1) == 1) return;
try
{
AppBuilder.Configure<HostApp>()
.UsePlatformDetect()
.AfterSetup(_ =>
{
IsAvailable = true;
_ready.TrySetResult(true);
})
.StartWithClassicDesktopLifetime(Array.Empty<string>());
}
catch (Exception ex)
{
// 无桌面会话(CI / 无头环境):模型窗口不可用,但后端其余接口照常。
LastError = ex.Message;
_ready.TrySetResult(false);
}
}
/// <summary>从任意线程请求结束事件循环,使 <see cref="RunOnCurrentThread"/> 返回。</summary>
public void Shutdown()
{
if (_started == 0) return;
try
{
Dispatcher.UIThread.Post(() =>
{
if (Application.Current?.ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
desktop.Shutdown();
});
}
catch
{
// 事件循环尚未建立或已退出:无需处理
}
}
/// <summary>在 Avalonia UI 线程上加载模型并打开它自己的窗口。</summary>
public async Task<string> LaunchAsync(ModelPackage package)
{
if (!await EnsureStartedAsync().ConfigureAwait(false))
throw new InvalidOperationException(
LastError ?? "无法初始化图形环境(当前会话没有桌面?)");
return await Dispatcher.UIThread.InvokeAsync<string>(async () =>
{
// 同一个模型已经在运行:把已有窗口提到前台,不再加载第二份实例
// (连点「启动模型」会各占一份内存与显存,低配机器直接卡死)。
lock (_gate)
{
if (_windows.TryGetValue(package.Id, out var existing))
{
try
{
if (existing.WindowState == WindowState.Minimized)
existing.WindowState = WindowState.Normal;
existing.Activate();
return $"模型 {package.Id} 已在运行";
}
catch
{
// 窗口已失效:清掉记录,按新窗口重新打开
_windows.Remove(package.Id);
}
}
}
PlayerWindow? window = null;
LoadedModel? loaded = null;
try
{
Action requestClose = () => Dispatcher.UIThread.Post(() =>
{
try { window?.Close(); } catch { /* 已关闭 */ }
});
loaded = await _services.ModelHost.LoadAsync(package, requestClose, null);
window = new PlayerWindow(package, loaded);
var captured = loaded;
var id = package.Id;
window.Closed += (_, _) =>
{
try { captured.Dispose(); } catch { /* 释放失败不影响退出 */ }
lock (_gate)
{
if (_windows.TryGetValue(id, out var current) && ReferenceEquals(current, window))
_windows.Remove(id);
}
};
lock (_gate) _windows[id] = window;
window.Show();
return $"已启动模型 {package.Id}";
}
catch
{
try { loaded?.Dispose(); } catch { /* 忽略 */ }
throw;
}
});
}
}
/// <summary>后端自己的 Avalonia 应用:没有主窗口,只用来承载模型窗口。</summary>
internal sealed class HostApp : Application
{
public override void Initialize() { }
public override void OnFrameworkInitializationCompleted()
{
if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
{
desktop.ShutdownMode = ShutdownMode.OnExplicitShutdown;
desktop.MainWindow = null;
}
base.OnFrameworkInitializationCompleted();
}
}
-708
View File
@@ -1,708 +0,0 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
using GC.Download;
using GC.Models;
using GC.Services;
using GC.UI.Server;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
namespace GC.UI.Server;
/// <summary>
/// GC-UI 后端(本地 HTTP 服务:模型扫描 / 下载 / 更新 / 设置 / 模型窗口宿主)。
///
/// 两种跑法共用同一份代码:
/// · 独立进程:<c>GC.UI.Server</c> 可执行文件(开发调试 / 旧包兼容);
/// · 进程内:启动器直接调用 <see cref="Start"/>,把后端跑在自己的进程里 ——
/// 发布包因此只需要一个 exe,不必再复制一份完整的 .NET 运行时。
/// </summary>
public static class BackendServer
{
/// <summary>按命令行 / GC_UI_PORT 解析端口并构建(未启动)的后端。</summary>
public static WebApplication StartFromCommandLine(string[] args)
=> Start(args, ResolvePort(args), out _);
/// <summary>同上,并交出模型窗口宿主(独立进程入口用:主线程留给 Avalonia)。</summary>
public static WebApplication StartFromCommandLine(string[] args, out AvaloniaHost uiHost)
=> Start(args, ResolvePort(args), out uiHost);
/// <summary>
/// 构建后端。返回的 <see cref="WebApplication"/> 尚未启动:
/// 独立进程直接 <c>Run()</c>,启动器用 <c>StartAsync()</c> 之后继续拉起界面。
/// </summary>
public static WebApplication Start(string[] args, int port)
=> Start(args, port, out _);
/// <summary>
/// 构建后端,并通过 <paramref name="uiHost"/> 交出模型窗口宿主。
///
/// 调用方(启动器)必须在**主线程**调用 <see cref="AvaloniaHost.RunOnCurrentThread"/>:
/// macOS 的 AppKit 要求 NSApplication 运行在主线程,否则打开模型窗口时整个进程会崩溃。
/// </summary>
public static WebApplication Start(string[] args, int port, out AvaloniaHost uiHost)
{
// 下载模块(GC-DOWNLOAD)通过宿主钩子注入,和 GC-BOOT 的做法一致。
DownloadModuleHost.Factory = new DownloadModuleFactory();
var services = AppServices.Create();
var host = new AvaloniaHost(services);
uiHost = host;
var builder = WebApplication.CreateBuilder(new WebApplicationOptions { Args = args });
builder.Logging.ClearProviders();
builder.WebHost.UseUrls($"http://127.0.0.1:{port}");
// 本地伴随进程:限制请求体大小、关闭 Server 头、收紧超时,减少被本地恶意页面
// 或异常客户端拖垮的攻击面。
builder.WebHost.ConfigureKestrel(options =>
{
options.AddServerHeader = false;
options.Limits.MaxRequestBodySize = 2 * 1024 * 1024;
options.Limits.RequestHeadersTimeout = TimeSpan.FromSeconds(15);
options.Limits.KeepAliveTimeout = TimeSpan.FromMinutes(2);
options.Limits.MaxConcurrentConnections = 64;
});
// 桌面端(Windows/macOS)走原生 HTTP,不需要 CORS;
// 这里放开本机回环来源,方便用 `flutter run -d chrome` 调试界面。
builder.Services.AddCors(options => options.AddDefaultPolicy(policy => policy
.SetIsOriginAllowed(origin =>
Uri.TryCreate(origin, UriKind.Absolute, out var uri) &&
(uri.Host == "127.0.0.1" || uri.Host == "localhost" || uri.Host == "::1"))
.AllowAnyHeader()
.AllowAnyMethod()));
var app = builder.Build();
app.UseCors();
// 日志与启动器共用 .GC/logs,整条启动链路(启动器 → 后端 → 守护进程)都在同一组文件里。
var logPaths = AppPaths.Discover();
GcLog.Init(logPaths.LogsRoot);
GcLog.Info($"GC-UI 后端启动,监听 127.0.0.1:{port}",
$"GC-UI backend started on 127.0.0.1:{port}");
// 设置白名单 / 标识校验用到的规则(只在本进程内使用)。
var allowedLanguages = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
{ "auto", "zh-CN", "en" };
var allowedThemes = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
{ "light", "dark", "system" };
var accentHexRegex = new System.Text.RegularExpressions.Regex(
"^#(?:[0-9A-Fa-f]{6})$", System.Text.RegularExpressions.RegexOptions.Compiled);
var safeIdRegex = new System.Text.RegularExpressions.Regex(
"^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$", System.Text.RegularExpressions.RegexOptions.Compiled);
// 安全响应头 + Host/Origin 校验(抵御 DNS rebinding 与跨站调用)。
app.Use(async (context, next) =>
{
var headers = context.Response.Headers;
headers["X-Content-Type-Options"] = "nosniff";
headers["X-Frame-Options"] = "DENY";
headers["Referrer-Policy"] = "no-referrer";
headers["Content-Security-Policy"] = "default-src 'none'; frame-ancestors 'none'";
headers["Cache-Control"] = "no-store";
var host = context.Request.Host.Host;
if (!string.Equals(host, "127.0.0.1", StringComparison.OrdinalIgnoreCase) &&
!string.Equals(host, "localhost", StringComparison.OrdinalIgnoreCase) &&
!string.Equals(host, "::1", StringComparison.OrdinalIgnoreCase))
{
context.Response.StatusCode = StatusCodes.Status403Forbidden;
return;
}
var origin = context.Request.Headers.Origin.ToString();
if (!string.IsNullOrEmpty(origin) &&
!(Uri.TryCreate(origin, UriKind.Absolute, out var parsed) &&
(parsed.Host == "127.0.0.1" || parsed.Host == "localhost" || parsed.Host == "::1")))
{
context.Response.StatusCode = StatusCodes.Status403Forbidden;
return;
}
await next();
});
// 写入类接口做简单限流:单 IP 每秒最多 40 次,防止本地脚本刷爆下载/更新。
var writeBuckets =
new System.Collections.Concurrent.ConcurrentDictionary<string, (long Window, int Count)>();
app.Use(async (context, next) =>
{
if (HttpMethods.IsPost(context.Request.Method) ||
HttpMethods.IsDelete(context.Request.Method))
{
var key = context.Connection.RemoteIpAddress?.ToString() ?? "local";
var now = Environment.TickCount64;
// 定期丢弃过期窗口:本机连接数不多,但长时间运行后桶只增不减会缓慢泄漏。
if (writeBuckets.Count > 256)
{
foreach (var entry in writeBuckets)
{
if (now - entry.Value.Window > 60_000)
writeBuckets.TryRemove(entry.Key, out _);
}
}
var bucket = writeBuckets.AddOrUpdate(
key,
_ => (now, 1),
(_, old) => now - old.Window > 1000 ? (now, 1) : (old.Window, old.Count + 1));
if (bucket.Count > 40)
{
context.Response.StatusCode = StatusCodes.Status429TooManyRequests;
await context.Response.WriteAsJsonAsync(ErrorDto.Of("请求过于频繁,请稍后再试"));
return;
}
}
await next();
});
// 会话令牌校验:启动器拉起时经 GC_UI_TOKEN 注入一次性令牌,前端每个 /api 请求
// 都必须带回。这样同机其他进程即使占了端口、伪造 /api/health 返回 200,也过不了
// 这一关——它拿不到令牌。独立进程 / 调试模式未设置令牌时放行,保持兼容。
var sessionToken = Environment.GetEnvironmentVariable(GcUiContract.TokenEnvVar);
if (!string.IsNullOrEmpty(sessionToken))
{
var expected = System.Text.Encoding.UTF8.GetBytes(sessionToken);
app.Use(async (context, next) =>
{
if (context.Request.Path.StartsWithSegments("/api"))
{
// 正常请求从请求头取;封面图由 Image.network 发起、无法加自定义头,
// 用同名 query 参数携带(GET 只读资源,参数不会落到日志正文)。
var supplied = context.Request.Headers[GcUiContract.TokenHeader].ToString();
if (string.IsNullOrEmpty(supplied))
supplied = context.Request.Query[GcUiContract.TokenHeader].ToString();
var actual = System.Text.Encoding.UTF8.GetBytes(supplied);
// 长度不等时 CryptographicOperations 仍安全比较,但先比对长度省一次分支泄漏。
if (actual.Length != expected.Length ||
!System.Security.Cryptography.CryptographicOperations.FixedTimeEquals(actual, expected))
{
context.Response.StatusCode = StatusCodes.Status401Unauthorized;
return;
}
}
await next();
});
}
// ---- 健康检查 -------------------------------------------------------------
app.MapGet("/api/health", () => Results.Ok(new HealthDto(
true,
LauncherRuntimeInfo.CurrentLauncherVersion,
LauncherRuntimeInfo.CurrentRid,
host.IsAvailable,
host.LastError,
GcUiContract.DeriveSessionProof(sessionToken))));
// ---- 已安装模型 -----------------------------------------------------------
app.MapGet("/api/models", () =>
Results.Ok(services.Models.Scan().Select(ToModelDto).ToList()));
app.MapGet("/api/models/{id}/preview", (string id, HttpResponse response) =>
{
if (!IsSafeId(id)) return Results.BadRequest(ErrorDto.Of("模型标识无效"));
var package = services.Models.Find(id);
if (package == null || !File.Exists(package.PreviewPath)) return Results.NotFound();
// 封面是静态图,允许前端缓存:默认全局中间件写的 no-store 会让每次滚动都重新请求。
// 按扩展名给准确的 MIME —— 统一写 image/png 时,WebP / JPEG 封面在部分平台显示不出来。
response.Headers.CacheControl = "private, max-age=300";
return Results.File(package.PreviewPath, GuessImageContentType(package.PreviewPath));
});
app.MapPost("/api/models/{id}/launch", async (string id) =>
{
if (!IsSafeId(id)) return Results.BadRequest(new LaunchResultDto(false, "模型标识无效"));
var package = services.Models.Find(id);
if (package == null) return Results.NotFound(new LaunchResultDto(false, $"没有找到模型 {id}"));
try
{
services.Memory.Refresh();
var message = await host.LaunchAsync(package);
return Results.Ok(new LaunchResultDto(true, message));
}
catch (Exception ex)
{
// 细节只写日志,不回显给调用方,避免泄漏本机路径等内部信息。
Console.Error.WriteLine($"[launch] 启动模型 {id} 失败: {ex}");
return Results.Json(new LaunchResultDto(false, "模型启动失败,请查看后端日志"), statusCode: 503);
}
});
app.MapDelete("/api/models/{id}", (string id) =>
{
if (!IsSafeId(id)) return Results.BadRequest(ErrorDto.Of("模型标识无效"));
var ok = services.Models.Delete(id);
if (ok) services.Models.NotifyChanged();
return ok
? Results.Ok(new LaunchResultDto(true, $"已删除模型 {id}"))
: Results.NotFound(ErrorDto.Of($"没有找到模型 {id}"));
});
// ---- 设置 -----------------------------------------------------------------
app.MapGet("/api/settings", () => Results.Ok(ToSettingsDto()));
app.MapPost("/api/settings", (SettingsPatch? patch) =>
{
if (patch == null) return Results.BadRequest(ErrorDto.Of("缺少设置内容"));
// 白名单校验:设置项会写进磁盘并被前端直接使用,不接受任意字符串。
if (patch.Language != null && !allowedLanguages.Contains(patch.Language))
return Results.BadRequest(ErrorDto.Of("不支持的界面语言"));
if (patch.Theme != null && !allowedThemes.Contains(patch.Theme))
return Results.BadRequest(ErrorDto.Of("不支持的主题"));
if (patch.AccentColor != null && !accentHexRegex.IsMatch(patch.AccentColor))
return Results.BadRequest(ErrorDto.Of("主题色需为 #RRGGBB"));
if (patch.UpdateRepository != null && !IsAllowedRepository(patch.UpdateRepository))
return Results.BadRequest(ErrorDto.Of("更新仓库地址不受信任"));
services.Settings.Apply(s =>
{
if (patch.Language != null) s.Language = patch.Language;
if (patch.Theme != null) s.Theme = patch.Theme;
if (patch.AccentColor != null) s.AccentColor = patch.AccentColor.ToUpperInvariant();
if (patch.RenderFps.HasValue) s.RenderFps = Math.Clamp(patch.RenderFps.Value, 12, 120);
if (patch.MemoryMb.HasValue) s.MemoryMb = Math.Clamp(patch.MemoryMb.Value, 256, 16384);
if (patch.MemoryAuto.HasValue) s.MemoryAuto = patch.MemoryAuto.Value;
if (patch.AutoUpdateOnStartup.HasValue) s.AutoUpdateOnStartup = patch.AutoUpdateOnStartup.Value;
if (patch.RequireSignedManifest.HasValue) s.RequireSignedManifest = patch.RequireSignedManifest.Value;
if (patch.UpdateRepository != null) s.UpdateRepository = patch.UpdateRepository;
if (patch.UpdateLocalRoot != null) s.UpdateLocalRoot = patch.UpdateLocalRoot;
if (patch.ModelRootOverride != null) s.ModelRootOverride = patch.ModelRootOverride;
});
if (patch.Language != null) L.I.SetLanguage(patch.Language);
if (patch.MemoryMb.HasValue || patch.MemoryAuto.HasValue)
services.Memory.ApplyAuto(services.Settings.Current.MemoryAuto, services.Settings.Current.MemoryMb);
return Results.Ok(ToSettingsDto());
});
// ---- 模型源 ---------------------------------------------------------------
app.MapGet("/api/sources", () =>
Results.Ok(services.Settings.Current.Sources.Select(ToSourceDto).ToList()));
app.MapPost("/api/sources/select", async (ForceRequest? request) =>
{
var force = request?.Force ?? false;
try
{
var fastest = await services.Selector.PickFastestAsync(force, CancellationToken.None);
services.Updates.UseRemote(services.DownloadModule.CreateRemote(fastest));
return Results.Ok(new LatencyDto(
fastest.Id, fastest.Name,
services.Selector.LastLatency.TryGetValue(fastest.Id, out var ms) ? ms : 0));
}
catch (Exception ex)
{
Console.Error.WriteLine($"[sources] 切换模型源失败: {ex}");
return Results.Json(ErrorDto.Of("模型源切换失败"), statusCode: 503);
}
});
app.MapGet("/api/remote/models", async (string? sourceId, bool force) =>
{
var source = ResolveSource(sourceId);
if (source == null) return Results.NotFound(ErrorDto.Of("没有可用的模型源"));
var index = await services.Sources.FetchAsync(source, force, null, CancellationToken.None);
var installed = services.Models.Scan()
.ToDictionary(p => p.Id, p => p.Manifest.Version, StringComparer.OrdinalIgnoreCase);
return Results.Ok(new SourceIndexDto(
index.SourceId,
index.Root,
index.FromCache,
index.Error,
index.ResolvedFrom,
index.Models.Select(m => new RemoteModelDto(
m.Id,
m.LocalizedName,
m.LocalizedDescription,
m.Manifest.Version,
m.SizeBytes,
ModelScanner.HumanSize(m.SizeBytes),
m.SourceId,
installed.ContainsKey(m.Id),
installed.TryGetValue(m.Id, out var v) ? v : null)).ToList()));
});
// ---- 下载 -----------------------------------------------------------------
app.MapPost("/api/download", async (DownloadRequest? request) =>
{
if (request == null || string.IsNullOrWhiteSpace(request.ModelId))
return Results.BadRequest(ErrorDto.Of("缺少 modelId"));
var source = ResolveSource(request.SourceId);
if (source == null) return Results.NotFound(ErrorDto.Of("没有可用的模型源"));
var index = await services.Sources.FetchAsync(source, false, null, CancellationToken.None);
var model = index.Models.FirstOrDefault(m =>
m.Id.Equals(request.ModelId, StringComparison.OrdinalIgnoreCase));
if (model == null)
return Results.NotFound(ErrorDto.Of($"源里没有模型 {request.ModelId}"));
var job = services.Downloads.Enqueue(model);
return Results.Ok(ToJobDto(job));
});
app.MapGet("/api/download/jobs", () =>
Results.Ok(services.Downloads.Jobs.Select(ToJobDto).ToList()));
app.MapPost("/api/download/{id}/cancel", (string id) =>
ActOnJob(id, job => services.Downloads.Cancel(job)));
app.MapPost("/api/download/{id}/retry", (string id) =>
ActOnJob(id, job => services.Downloads.Retry(job)));
app.MapPost("/api/download/{id}/remove", (string id) =>
ActOnJob(id, job => services.Downloads.Remove(job)));
app.MapPost("/api/download/clear-finished", () =>
{
services.Downloads.ClearFinished();
return Results.Ok(new LaunchResultDto(true, "已清除完成的任务"));
});
// ---- 更新 -----------------------------------------------------------------
app.MapPost("/api/update/check", async (ForceRequest? request) =>
{
var force = request?.Force ?? true;
var messages = new List<string>();
try
{
var fastest = await services.Selector.PickFastestAsync(force, CancellationToken.None);
services.Updates.UseRemote(services.DownloadModule.CreateRemote(fastest));
}
catch (Exception ex)
{
Console.Error.WriteLine($"[update] 测速失败,沿用当前源: {ex.Message}");
}
string? launcherLatest = null;
try
{
launcherLatest = await services.LauncherUpdates.CheckAsync(
services.Updates.Remote, CancellationToken.None);
}
catch (Exception ex)
{
Console.Error.WriteLine($"[update] 启动器版本检查失败: {ex.Message}");
}
var progress = new Progress<UpdateProgress>(p =>
{
if (!string.IsNullOrWhiteSpace(p.Message)) messages.Add(p.Message);
});
var result = await services.Updates.RunAsync(force, progress, CancellationToken.None);
return Results.Ok(new UpdateCheckDto(
result.Outcome.ToString(),
result.Message,
result.UpdatedModels,
result.ModelNames,
result.LauncherMessage,
result.Error,
launcherLatest,
services.Updates.Remote.DisplayName,
services.Selector.LastLatency
.Select(kv => new LatencyDto(
kv.Key,
SourcePreset.Find(kv.Key)?.Name ?? kv.Key,
kv.Value))
.ToList()));
});
// ---- 关于 -----------------------------------------------------------------
app.MapGet("/api/about", async () =>
{
var repository = services.Settings.Current.UpdateRepository;
var contributors = new List<ContributorDto>();
try
{
foreach (var c in await ContributorsService.FetchAsync(repository, CancellationToken.None))
contributors.Add(new ContributorDto(c.DisplayName, c.Contributions, c.AvatarUrl));
}
catch (Exception ex)
{
Console.Error.WriteLine($"[about] 读取贡献者失败: {ex.Message}");
}
return Results.Ok(new AboutDto(
"Morris GC",
LauncherRuntimeInfo.CurrentLauncherVersion,
LauncherRuntimeInfo.CurrentRid,
repository,
contributors,
// 「关于」页展示的技术栈信息:源码语言与前端框架。
SourceLanguage: "C#",
Frontend: "Flutter"));
});
// ---- 系统集成 -------------------------------------------------------------
app.MapPost("/api/shell/open-folder", (PathRequest? request) =>
{
var path = request?.Path;
if (string.IsNullOrWhiteSpace(path))
return Results.BadRequest(ErrorDto.Of("缺少 path"));
// 只允许打开启动器自己的目录,避免前端被当成任意路径执行器
if (!IsInsideKnownRoot(path!))
return Results.BadRequest(ErrorDto.Of("只允许打开启动器自己的目录"));
Shell.OpenFolder(path!);
return Results.Ok(new LaunchResultDto(true, "已打开目录"));
});
app.MapPost("/api/shell/open-url", (UrlRequest? request) =>
{
var url = request?.Url;
if (string.IsNullOrWhiteSpace(url) || url.Length > 2048 ||
!Uri.TryCreate(url, UriKind.Absolute, out var uri))
return Results.BadRequest(ErrorDto.Of("URL 无效"));
if (uri.Scheme != Uri.UriSchemeHttp && uri.Scheme != Uri.UriSchemeHttps)
return Results.BadRequest(ErrorDto.Of("只允许 http/https 链接"));
if (!string.IsNullOrEmpty(uri.UserInfo))
return Results.BadRequest(ErrorDto.Of("URL 不允许携带账号密码"));
Shell.OpenUrl(url!);
return Results.Ok(new LaunchResultDto(true, "已打开链接"));
});
// ---- 启动 -----------------------------------------------------------------
WriteEndpointFile(services, port);
Console.WriteLine($"[GC-UI] 后端已启动: http://127.0.0.1:{port}");
Console.WriteLine($"[GC-UI] 模型库: {services.Paths.ModelRoot}");
return app;
// ---------------------------------------------------------------------------
// 局部辅助
// ---------------------------------------------------------------------------
static void WriteEndpointFile(AppServices services, int port)
{
try
{
var file = Path.Combine(services.Paths.HomeRoot, "ui-backend.json");
var payload = JsonSerializer.Serialize(new
{
port,
pid = Environment.ProcessId,
url = $"http://127.0.0.1:{port}",
version = LauncherRuntimeInfo.CurrentLauncherVersion,
platform = LauncherRuntimeInfo.CurrentRid,
startedAt = DateTimeOffset.UtcNow.ToString("o")
}, new JsonSerializerOptions { WriteIndented = true });
File.WriteAllText(file, payload);
}
catch (Exception ex)
{
Console.Error.WriteLine($"[GC-UI] 写入端点文件失败: {ex.Message}");
}
}
/// <summary>按扩展名推断图片 MIME;模型封面允许 png / jpg / webp / gif。</summary>
static string GuessImageContentType(string path) => Path.GetExtension(path).ToLowerInvariant() switch
{
".jpg" or ".jpeg" => "image/jpeg",
".webp" => "image/webp",
".gif" => "image/gif",
".bmp" => "image/bmp",
".svg" => "image/svg+xml",
_ => "image/png"
};
ModelDto ToModelDto(ModelPackage package) => new( package.Id,
package.LocalizedName,
package.LocalizedDescription,
package.Manifest.Version,
package.Manifest.Author,
package.SizeBytes,
ModelScanner.HumanSize(package.SizeBytes),
package.Manifest.Tags ?? new List<string>(),
File.Exists(package.PreviewPath),
$"/api/models/{package.Id}/preview",
package.Directory,
package.DataDirectory);
SourceDto ToSourceDto(ModelSource source) => new(
source.Id,
string.IsNullOrWhiteSpace(source.Name) ? source.Id : source.Name,
source.Url,
source.Enabled,
source.BuiltIn,
source.DisplayHost);
SettingsDto ToSettingsDto() => new(
services.Settings.Current.Language,
services.Settings.Current.Theme,
services.Settings.Current.AccentColor,
services.Settings.Current.RenderFps,
services.Settings.Current.MemoryMb,
services.Settings.Current.MemoryAuto,
services.Settings.Current.AutoUpdateOnStartup,
services.Settings.Current.RequireSignedManifest,
services.Settings.Current.UpdateRepository,
services.Settings.Current.UpdateLocalRoot,
services.Settings.Current.ModelRootOverride,
services.Memory.BudgetMb,
services.Memory.UsageText,
services.Paths.ModelRoot,
services.Paths.DataRoot,
services.Paths.SettingsFile,
LauncherRuntimeInfo.CurrentLauncherVersion,
LauncherRuntimeInfo.CurrentRid,
services.Settings.Current.Sources.Select(ToSourceDto).ToList(),
L.Supported.Select(s => new LanguageDto(s.Code, s.Label)).ToList());
JobDto ToJobDto(IDownloadJob job) => new(
job.Id,
job.Model.Id,
job.Name,
job.Version,
job.State.ToString(),
job.Progress,
job.StatusText,
job.DetailText,
job.Error,
job.IsActive,
job.CanRetry,
job.IsDone);
ModelSource? ResolveSource(string? sourceId)
{
var sources = services.Settings.Current.Sources;
if (!string.IsNullOrWhiteSpace(sourceId))
{
var exact = sources.FirstOrDefault(s =>
s.Id.Equals(sourceId, StringComparison.OrdinalIgnoreCase));
if (exact != null) return exact;
}
return sources.FirstOrDefault(s => s.Enabled && !string.IsNullOrWhiteSpace(s.Url))
?? sources.FirstOrDefault();
}
IResult ActOnJob(string id, Action<IDownloadJob> action)
{
if (!IsSafeId(id)) return Results.BadRequest(ErrorDto.Of("任务标识无效"));
var job = services.Downloads.Jobs.FirstOrDefault(j =>
j.Id.Equals(id, StringComparison.OrdinalIgnoreCase));
if (job == null) return Results.NotFound(ErrorDto.Of($"没有找到任务 {id}"));
action(job);
return Results.Ok(ToJobDto(job));
}
bool IsInsideKnownRoot(string path)
{
try
{
var full = Path.GetFullPath(path);
var roots = new[]
{
services.Paths.ModelRoot,
services.Paths.DataRoot,
services.Paths.HomeRoot,
services.Paths.AppRoot
};
foreach (var root in roots)
{
if (string.IsNullOrWhiteSpace(root)) continue;
var rootFull = Path.GetFullPath(root);
if (full.Equals(rootFull, StringComparison.OrdinalIgnoreCase)) return true;
if (full.StartsWith(rootFull + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase))
return true;
}
}
catch
{
return false;
}
return false;
}
// 路由标识:只允许字母数字开头,后接字母数字/点/下划线/短横线,长度上限 64。
// 用于模型 id、任务 id,杜绝 `../` 之类的路径穿越尝试。
bool IsSafeId(string? id) => !string.IsNullOrEmpty(id) && safeIdRegex.IsMatch(id);
// 更新仓库地址:必须是 https、不带账号密码、不是回环/内网 IP。
// 防止把本地后端当成 SSRF 跳板去访问内网服务。
bool IsAllowedRepository(string value)
{
if (string.IsNullOrWhiteSpace(value)) return false;
if (!Uri.TryCreate(value, UriKind.Absolute, out var uri)) return false;
if (uri.Scheme != Uri.UriSchemeHttps) return false;
if (!string.IsNullOrEmpty(uri.UserInfo)) return false;
if (string.Equals(uri.Host, "localhost", StringComparison.OrdinalIgnoreCase)) return false;
if (System.Net.IPAddress.TryParse(uri.Host, out var ip) &&
(System.Net.IPAddress.IsLoopback(ip) || IsPrivateAddress(ip)))
return false;
return true;
}
static bool IsPrivateAddress(System.Net.IPAddress ip)
{
var bytes = ip.GetAddressBytes();
if (bytes.Length != 4) return false;
return bytes[0] == 10
|| (bytes[0] == 172 && bytes[1] >= 16 && bytes[1] <= 31)
|| (bytes[0] == 192 && bytes[1] == 168)
|| (bytes[0] == 169 && bytes[1] == 254);
}
}
public static int ResolvePort(string[] args)
{
// 优先用启动器传来的端口(GC_UI_PORT),保证前端拼出来的 baseUrl 和这里一致。
var env = Environment.GetEnvironmentVariable(GcUiContract.PortEnvVar);
if (int.TryParse(env, out var fromEnv) && fromEnv > 0 && fromEnv < 65536) return fromEnv;
for (var i = 0; i < args.Length; i++)
{
if (args[i] == "--port" && i + 1 < args.Length &&
int.TryParse(args[i + 1], out var next) && next > 0 && next < 65536)
return next;
const string prefix = "--port=";
if (args[i].StartsWith(prefix, StringComparison.Ordinal) &&
int.TryParse(args[i][prefix.Length..], out var inline) && inline > 0 && inline < 65536)
return inline;
}
return GcUiContract.DefaultPort;
}
}
@@ -1,33 +0,0 @@
<Project Sdk="Microsoft.NET.Sdk.Web">
<!--
GC-UI 后端:把原来「启动器 = UI + 服务」的一体式结构拆成
· 后端(本工程):模型扫描 / 下载 / 更新 / 设置 / 模型窗口宿主,只暴露本地 HTTP API
· 前端(GC-UI/frontend,Flutter):只做界面,通过 HTTP 调后端
模型窗口仍然由 .NET 侧承载:模型 dll 返回的是 Avalonia Control,
换掉渲染栈等于换掉模型契约,所以「渲染留在 .NET,界面交给 Flutter」是唯一不破坏模型生态的切法。
-->
<PropertyGroup>
<OutputType>Exe</OutputType>
<Nullable>enable</Nullable>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<RootNamespace>GC.UI.Server</RootNamespace>
<AssemblyName>GC.UI.Server</AssemblyName>
<InvariantGlobalization>false</InvariantGlobalization>
<AvaloniaUseCompiledBindingsByDefault>false</AvaloniaUseCompiledBindingsByDefault>
<!-- 后端是本地伴随进程,不需要浏览器启动配置 / 静态文件 -->
<GenerateDocumentationFile>false</GenerateDocumentationFile>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Avalonia" Version="$(AvaloniaVersion)" />
<PackageReference Include="Avalonia.Desktop" Version="$(AvaloniaVersion)" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\..\..\GC\src\GC.Core.csproj" />
<ProjectReference Include="..\..\..\GC-DOWNLOAD\GC-DOWNLOAD.csproj" />
</ItemGroup>
</Project>
-22
View File
@@ -1,22 +0,0 @@
using GC.UI.Server;
using Microsoft.Extensions.Hosting;
// 独立进程入口:`GC.UI.Server --port 17890`
// 启动器在进程内直接调用 BackendServer.Start,不会走到这里。
var app = BackendServer.StartFromCommandLine(args, out var host);
// 模型窗口由 Avalonia 承载,macOS 的 AppKit 要求 NSApplication 在主线程。
// 所以后端交给 Kestrel 自己的线程池在后台跑,主线程留给 Avalonia 事件循环。
app.StartAsync().GetAwaiter().GetResult();
host.RunOnCurrentThread();
if (host.IsAvailable)
{
// 事件循环结束 → 收尾后端
app.StopAsync().GetAwaiter().GetResult();
}
else
{
// 无图形环境(无头调试):退化为纯后端常驻
app.WaitForShutdown();
}
-29
View File
@@ -1,29 +0,0 @@
@echo off
REM 构建 GC-UI 前端(Windows 上运行;macOS 请用 build-ui.sh)。
REM
REM GC-UI\build-ui.cmd
setlocal
set ROOT=%~dp0..
set FRONTEND=%ROOT%\GC-UI\frontend
where flutter >nul 2>nul
if errorlevel 1 (
echo 找不到 flutter,请先安装 Flutter SDK 并加入 PATH。
exit /b 1
)
echo ==^> 构建后端(GC.UI.Server)
dotnet build "%ROOT%\GC-UI\backend\GC.UI.Server\GC.UI.Server.csproj" -c Release
if errorlevel 1 exit /b 1
echo ==^> 构建前端(windows)
cd /d "%FRONTEND%"
call flutter pub get
if errorlevel 1 exit /b 1
call flutter build windows --release
if errorlevel 1 exit /b 1
echo ==^> 完成
echo 产物: %FRONTEND%\build\windows\x64\runner\Release\
endlocal
-37
View File
@@ -1,37 +0,0 @@
#!/usr/bin/env bash
# 构建 GC-UI 前端(macOS / Linux 上运行;Windows 请用 build-ui.cmd)。
#
# ./GC-UI/build-ui.sh # 构建当前平台
# ./GC-UI/build-ui.sh macos # 指定目标
set -euo pipefail
ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
FRONTEND="$ROOT/GC-UI/frontend"
TARGET="${1:-}"
if ! command -v flutter >/dev/null 2>&1; then
echo "找不到 flutter,请先安装 Flutter SDK 并加入 PATH。" >&2
exit 1
fi
if [ -z "$TARGET" ]; then
case "$(uname -s)" in
Darwin) TARGET="macos" ;;
*) TARGET="macos" ;;
esac
fi
echo "==> 构建后端(GC.UI.Server)"
dotnet build "$ROOT/GC-UI/backend/GC.UI.Server/GC.UI.Server.csproj" -c Release
echo "==> 构建前端($TARGET)"
cd "$FRONTEND"
flutter pub get
flutter build "$TARGET" --release
echo "==> 完成"
case "$TARGET" in
macos) echo "产物: $FRONTEND/build/macos/Build/Products/Release/" ;;
windows) echo "产物: $FRONTEND/build/windows/x64/runner/Release/" ;;
*) echo "产物: $FRONTEND/build/$TARGET/" ;;
esac
-43
View File
@@ -1,43 +0,0 @@
# Miscellaneous
*.class
*.log
*.pyc
*.swp
.DS_Store
.atom/
.buildlog/
.history
.svn/
migrate_working_dir/
# IntelliJ related
*.iml
*.ipr
*.iws
.idea/
# The .vscode folder contains launch configuration and tasks you configure in
# VS Code which you may wish to be included in version control, so this line
# is commented out by default.
#.vscode/
# Flutter/Dart/Pub related
**/doc/api/
**/ios/Flutter/.last_build_id
.dart_tool/
.flutter-plugins
.flutter-plugins-dependencies
.pub-cache/
.pub/
/build/
# Symbolication related
app.*.symbols
# Obfuscation related
app.*.map.json
# Android Studio will place build artifacts here
/android/app/debug
/android/app/profile
/android/app/release
-36
View File
@@ -1,36 +0,0 @@
# This file tracks properties of this Flutter project.
# Used by Flutter tool to assess capabilities and perform upgrades etc.
#
# This file should be version controlled and should not be manually edited.
version:
revision: "dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668"
channel: "stable"
project_type: app
# Tracks metadata for the flutter migrate command
migration:
platforms:
- platform: root
create_revision: dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668
base_revision: dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668
- platform: linux
create_revision: dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668
base_revision: dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668
- platform: macos
create_revision: dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668
base_revision: dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668
- platform: windows
create_revision: dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668
base_revision: dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668
# User provided section
# List of Local paths (relative to this file) that should be
# ignored by the migrate tool.
#
# Files that are not part of the templates will be ignored by default.
unmanaged_files:
- 'lib/main.dart'
- 'ios/Runner.xcodeproj/project.pbxproj'
-16
View File
@@ -1,16 +0,0 @@
# gc_ui
GC launcher UI (Flutter frontend)
## Getting Started
This project is a starting point for a Flutter application.
A few resources to get you started if this is your first Flutter project:
- [Lab: Write your first Flutter app](https://docs.flutter.dev/get-started/codelab)
- [Cookbook: Useful Flutter samples](https://docs.flutter.dev/cookbook)
For help getting started with Flutter development, view the
[online documentation](https://docs.flutter.dev/), which offers tutorials,
samples, guidance on mobile development, and a full API reference.
-28
View File
@@ -1,28 +0,0 @@
# This file configures the analyzer, which statically analyzes Dart code to
# check for errors, warnings, and lints.
#
# The issues identified by the analyzer are surfaced in the UI of Dart-enabled
# IDEs (https://dart.dev/tools#ides-and-editors). The analyzer can also be
# invoked from the command line by running `flutter analyze`.
# The following line activates a set of recommended lints for Flutter apps,
# packages, and plugins designed to encourage good coding practices.
include: package:flutter_lints/flutter.yaml
linter:
# The lint rules applied to this project can be customized in the
# section below to disable rules from the `package:flutter_lints/flutter.yaml`
# included above or to enable additional rules. A list of all available lints
# and their documentation is published at https://dart.dev/lints.
#
# Instead of disabling a lint rule for the entire project in the
# section below, it can also be suppressed for a single line of code
# or a specific dart file by using the `// ignore: name_of_lint` and
# `// ignore_for_file: name_of_lint` syntax on the line or in the file
# producing the lint.
rules:
# avoid_print: false # Uncomment to disable the `avoid_print` rule
# prefer_single_quotes: true # Uncomment to enable the `prefer_single_quotes` rule
# Additional information about this file can be found at
# https://dart.dev/guides/language/analysis-options
-663
View File
@@ -1,663 +0,0 @@
(function () {
"use strict";
const STEP_COPY = [
{ title: "等高切割", description: "观察水平面与山体在同一海拔相交,形成连续闭合线。" },
{ title: "形成交线", description: "每个水平切面都会留下同高交线,多层交线共同描述山体起伏。" },
{ title: "投影成图", description: "把各高度交线垂直投影到同一平面,得到完整等高线地形图。" },
{ title: "疏密判坡", description: "等高线越密,坡度越陡;等高线越疏,坡度越缓。" }
];
const DEFAULT_VIEW = {
title: "实验流程",
summary: "点击开始实验,在当前背景中观察等高切割与交线形成,再通过右侧图解理解垂直投影和疏密判坡。",
features: ["同一条等高线上海拔相等", "相邻等高线高差保持一致"],
hint: "点击“开始实验”,直接在当前画面播放形成交线视频"
};
const LANDFORMS = {
peak: {
name: "山峰",
subtitle: "闭合等高线",
image: "assets/peak-3d.jpg",
topImage: "assets/peak-top.jpg",
alt: "山峰立体示意图,蓝色等高线围绕山体逐级闭合",
topAlt: "山峰真实俯视图,多层近同心闭合等高线向中心收缩",
summary: "山峰四周较低、中心突起;等高线闭合成环,海拔数值由外向内逐渐升高。",
features: ["中心海拔高、四周海拔低", "闭合线越向内,数值越大", "若数值向内降低,则应判为洼地"],
hint: "山峰:闭合曲线,数值向中心升高"
},
ridge: {
name: "山脊",
subtitle: "凸低为脊",
image: "assets/ridge-3d.jpg",
topImage: "assets/ridge-top.jpg",
alt: "山脊立体示意图,蓝色等高线沿凸出的脊线向低处弯曲",
topAlt: "山脊真实俯视图,等高线沿狭长高地呈舌状延伸",
summary: "等高线弯曲部分向海拔低处凸出,脊线常成为两侧水系的分水岭。",
features: ["等高线凸向低值方向", "脊线由高处向低处延伸", "雨水沿脊线两侧分流"],
hint: "山脊:等高线向低处凸出,凸低为脊"
},
valley: {
name: "山谷",
subtitle: "凸高为谷",
image: "assets/valley-3d.jpg",
topImage: "assets/valley-top.jpg",
alt: "山谷立体示意图,两座山体之间的谷地有河流穿过",
topAlt: "山谷真实俯视图,两侧坡面夹持低槽,等高线形成 V 形凹入",
summary: "等高线弯曲部分向海拔高处凸出,谷底低洼并容易汇水形成河流。",
features: ["等高线凸向高值方向", "V 形尖端指向上游高处", "谷底常发育河流"],
hint: "山谷:等高线向高处凸出,凸高为谷"
},
saddle: {
name: "鞍部",
subtitle: "两峰之间",
image: "assets/saddle-3d.jpg",
topImage: "assets/saddle-top.jpg",
alt: "鞍部立体示意图,两座山峰之间形成马鞍状低地",
topAlt: "鞍部真实俯视图,两组峰顶闭合圈之间的等高线明显收腰",
summary: "鞍部位于相邻两座山峰之间,是沿山脊方向相对低洼的过渡地带。",
features: ["两组闭合等高线相邻", "中部线条收窄,形似马鞍", "常是翻越山岭的低垭口"],
hint: "鞍部:两峰之间相对低洼,俯视轮廓呈收腰形"
},
cliff: {
name: "陡崖",
subtitle: "密集或重合",
image: "assets/cliff-3d.jpg",
topImage: "assets/cliff-top.jpg",
alt: "陡崖立体示意图,崖壁处蓝色等高线高度密集",
topAlt: "陡崖真实俯视图,崖壁处大量等高线极密集并近似重合",
summary: "陡崖坡面近直立,不同高程的等高线会高度密集,局部可投影到同一位置而重合。",
features: ["密集表示陡坡,重合才是陡崖特征", "单位水平距离内高差很大", "n 条线重合时:(n−1)d ≤ ΔH < (n+1)d"],
hint: "陡崖:等高线密集或重合,坡度极陡"
}
};
const dom = {
app: document.getElementById("app-shell"),
experimentVideo: document.getElementById("experiment-video"),
densityBackground: document.getElementById("density-background"),
landformImage: document.getElementById("landform-image"),
landformTopImage: document.getElementById("landform-top-image"),
projectionDiagram: document.getElementById("projection-diagram"),
densityDiagram: document.getElementById("density-diagram"),
mediaLoading: document.getElementById("media-loading"),
mediaLabelKicker: document.getElementById("media-label-kicker"),
mediaLabelTitle: document.getElementById("media-label-title"),
mediaLabelCopy: document.getElementById("media-label-copy"),
progress: document.getElementById("video-progress-fill"),
playButton: document.getElementById("play-button"),
playIcon: document.getElementById("play-icon"),
playLabel: document.getElementById("play-label"),
resetButton: document.getElementById("reset-button"),
fullscreenButton: document.getElementById("fullscreen-button"),
fullscreenLabel: document.getElementById("fullscreen-label"),
workflowOpen: document.getElementById("workflow-open"),
flowSteps: Array.from(document.querySelectorAll(".flow-step[data-step]")),
flowCount: document.getElementById("flow-count"),
flowLineFill: document.getElementById("flow-line-fill"),
taskTitle: document.getElementById("task-title"),
taskDescription: document.getElementById("task-description"),
terrainTabs: Array.from(document.querySelectorAll(".terrain-tab[data-landform]")),
returnExperiment: document.getElementById("return-experiment"),
observationHeading: document.getElementById("observation-heading"),
observationSummary: document.getElementById("observation-summary"),
featureList: document.getElementById("feature-list"),
topViewToggle: document.getElementById("top-view-toggle"),
topViewToggleLabel: document.getElementById("top-view-toggle-label"),
topViewToggleHint: document.getElementById("top-view-toggle-hint"),
topViewThumbnail: document.getElementById("top-view-thumbnail"),
hintText: document.getElementById("hint-text"),
controlPanel: document.querySelector(".control-panel"),
panelClose: document.getElementById("panel-close"),
panelOpen: document.getElementById("panel-open"),
toast: document.getElementById("toast")
};
const state = {
selectedLandform: null,
pendingLandform: null,
viewMode: "perspective",
step: 0,
imageToken: 0,
scanTimer: 0,
annotationTimer: 0,
toastTimer: 0,
pendingStep: null,
workflowTimer: 0,
workflowRunToken: 0,
workflowAutoPlaying: false
};
const ICONS = {
play: '<svg viewBox="0 0 24 24"><path d="m9 6 9 6-9 6V6Z"/></svg>',
pause: '<svg viewBox="0 0 24 24"><path d="M7 6h4v12H7V6Zm6 0h4v12h-4V6Z"/></svg>'
};
function showToast(message) {
window.clearTimeout(state.toastTimer);
dom.toast.textContent = message;
dom.toast.classList.add("is-visible");
state.toastTimer = window.setTimeout(function () {
dom.toast.classList.remove("is-visible");
}, 2600);
}
function hideLoading() {
dom.mediaLoading.classList.add("is-hidden");
}
function cancelWorkflowSequence() {
window.clearTimeout(state.workflowTimer);
state.workflowTimer = 0;
state.workflowRunToken += 1;
state.workflowAutoPlaying = false;
}
function setWorkflowDiagram(element, active) {
element.toggleAttribute("hidden", !active);
element.classList.toggle("is-active", active);
}
function hideWorkflowVisuals() {
setWorkflowDiagram(dom.projectionDiagram, false);
setWorkflowDiagram(dom.densityDiagram, false);
dom.densityBackground.classList.remove("is-visible");
dom.app.classList.remove("has-workflow-visual");
}
function syncWorkflowPresentation(index) {
const safeIndex = Math.max(0, Math.min(3, Number(index) || 0));
const isExperiment = !state.selectedLandform;
const showProjection = isExperiment && safeIndex === 2;
const showDensity = isExperiment && safeIndex === 3;
const densityWasVisible = dom.densityBackground.classList.contains("is-visible");
setWorkflowDiagram(dom.projectionDiagram, showProjection);
setWorkflowDiagram(dom.densityDiagram, showDensity);
dom.densityBackground.classList.toggle("is-visible", showDensity);
dom.app.classList.toggle("has-workflow-visual", showProjection || showDensity);
if (isExperiment) dom.experimentVideo.classList.toggle("is-visible", !showDensity);
if (showDensity && !densityWasVisible) triggerScan(dom.densityBackground);
}
function beginStaticWorkflowSequence() {
cancelWorkflowSequence();
const token = state.workflowRunToken;
state.workflowAutoPlaying = true;
renderStep(2);
setPlayButton();
dom.hintText.textContent = "自动演示:" + STEP_COPY[2].description;
state.workflowTimer = window.setTimeout(function () {
if (token !== state.workflowRunToken) return;
renderStep(3);
dom.hintText.textContent = "自动演示:" + STEP_COPY[3].description;
state.workflowTimer = window.setTimeout(function () {
if (token !== state.workflowRunToken) return;
state.workflowTimer = 0;
state.workflowAutoPlaying = false;
setPlayButton();
dom.hintText.textContent = "实验流程播放完成 · 可重新实验或选择典型地貌观察";
}, 3600);
}, 3200);
}
function renderStep(index) {
const safeIndex = Math.max(0, Math.min(3, Number(index) || 0));
state.step = safeIndex;
const copy = STEP_COPY[safeIndex];
dom.flowCount.textContent = (safeIndex + 1) + "/4";
dom.flowLineFill.style.width = (safeIndex / 3) * 100 + "%";
dom.taskTitle.textContent = copy.title;
dom.taskDescription.textContent = copy.description;
dom.flowSteps.forEach(function (button, buttonIndex) {
button.classList.toggle("is-active", buttonIndex === safeIndex);
button.classList.toggle("is-complete", buttonIndex < safeIndex);
button.setAttribute("aria-current", buttonIndex === safeIndex ? "step" : "false");
});
syncWorkflowPresentation(safeIndex);
}
function renderObservation(view) {
dom.observationHeading.textContent = view.name || view.title;
dom.observationSummary.textContent = view.summary;
dom.featureList.replaceChildren();
view.features.forEach(function (feature) {
const item = document.createElement("li");
item.textContent = feature;
dom.featureList.appendChild(item);
});
}
function setPlayButton() {
const duration = dom.experimentVideo.duration;
const finished = dom.experimentVideo.ended || (Number.isFinite(duration) && duration > 0 && dom.experimentVideo.currentTime >= duration - 0.08);
if (!dom.experimentVideo.paused) {
dom.playLabel.textContent = "暂停实验";
dom.playIcon.innerHTML = ICONS.pause;
return;
}
dom.playIcon.innerHTML = ICONS.play;
if (!state.selectedLandform && state.step >= 2) {
dom.playLabel.textContent = "重新实验";
return;
}
if (finished) dom.playLabel.textContent = "重新实验";
else if (dom.experimentVideo.currentTime > 0.12) dom.playLabel.textContent = "继续实验";
else dom.playLabel.textContent = "开始实验";
}
function updateMediaLabel(view) {
if (view) {
dom.mediaLabelKicker.textContent = state.viewMode === "top" ? "典型地貌 · 真实俯视图" : "典型地貌 · 立体示意";
dom.mediaLabelTitle.textContent = view.name;
dom.mediaLabelCopy.textContent = state.viewMode === "top" ? view.subtitle + "|" + view.summary : view.summary;
return;
}
dom.mediaLabelKicker.textContent = "实验流程";
dom.mediaLabelTitle.textContent = "形成交线与垂直投影";
dom.mediaLabelCopy.textContent = dom.experimentVideo.paused
? "点击“开始实验”,直接在当前画面播放形成交线视频"
: STEP_COPY[state.step].description;
}
function updateViewToggle() {
const view = LANDFORMS[state.selectedLandform];
const hasLandform = Boolean(view);
const isTopView = hasLandform && state.viewMode === "top";
dom.topViewToggle.disabled = !hasLandform;
dom.topViewToggle.classList.toggle("is-active", isTopView);
dom.topViewToggle.setAttribute("aria-pressed", String(isTopView));
dom.topViewToggleLabel.textContent = isTopView ? "立体图" : "俯视图";
dom.topViewToggleHint.textContent = hasLandform ? "点击切换" : "选择地貌后切换";
dom.topViewToggle.setAttribute(
"aria-label",
hasLandform ? "切换为" + (isTopView ? "立体图" : "俯视图") : "请先选择一种典型地貌"
);
if (!view) {
dom.topViewThumbnail.hidden = true;
dom.topViewThumbnail.removeAttribute("src");
dom.topViewThumbnail.alt = "";
return;
}
dom.topViewThumbnail.src = isTopView ? view.image : view.topImage;
dom.topViewThumbnail.alt = isTopView ? view.name + "立体图预览" : view.name + "真实俯视图预览";
dom.topViewThumbnail.hidden = false;
}
function triggerScan(targetImage) {
window.clearTimeout(state.scanTimer);
dom.app.classList.remove("is-scanning");
dom.densityBackground.classList.remove("is-revealing");
dom.landformImage.classList.remove("is-revealing");
dom.landformTopImage.classList.remove("is-revealing");
void dom.app.offsetWidth;
dom.app.classList.add("is-scanning");
(targetImage || (state.viewMode === "top" ? dom.landformTopImage : dom.landformImage)).classList.add("is-revealing");
state.scanTimer = window.setTimeout(function () {
dom.app.classList.remove("is-scanning");
dom.densityBackground.classList.remove("is-revealing");
dom.landformImage.classList.remove("is-revealing");
dom.landformTopImage.classList.remove("is-revealing");
}, 1220);
}
async function decodeImage(image) {
if (typeof image.decode === "function") {
await image.decode();
return;
}
if (!image.complete) {
await new Promise(function (resolve, reject) {
image.addEventListener("load", resolve, { once: true });
image.addEventListener("error", reject, { once: true });
});
}
}
function hideTerrainAnnotation() {
window.clearTimeout(state.annotationTimer);
dom.app.classList.remove("is-landform");
if (window.TerrainAnnotation) window.TerrainAnnotation.hide();
}
function clearTerrainAnnotationNow() {
window.clearTimeout(state.annotationTimer);
state.annotationTimer = 0;
if (window.TerrainAnnotation) window.TerrainAnnotation.hide(true);
}
function scheduleTerrainAnnotation(withScan) {
window.clearTimeout(state.annotationTimer);
dom.app.classList.add("is-landform");
state.annotationTimer = window.setTimeout(function () {
if (!state.selectedLandform || !window.TerrainAnnotation) return;
window.TerrainAnnotation.show(state.selectedLandform, state.viewMode);
}, withScan ? 420 : 0);
}
function applyLandformView(view, withScan) {
const isTopView = state.viewMode === "top";
hideWorkflowVisuals();
dom.experimentVideo.classList.remove("is-visible");
dom.landformImage.classList.toggle("is-visible", !isTopView);
dom.landformTopImage.classList.toggle("is-visible", isTopView);
updateMediaLabel(view);
updateViewToggle();
dom.hintText.textContent = isTopView
? view.name + "俯视图:" + view.hint.replace(view.name + ":", "")
: view.hint;
if (withScan) triggerScan();
scheduleTerrainAnnotation(withScan);
}
function collapsePanelForCompactView() {
if (!window.matchMedia("(max-width: 680px)").matches) return;
dom.controlPanel.classList.add("is-collapsed");
dom.panelOpen.hidden = false;
}
async function selectLandform(key) {
const view = LANDFORMS[key];
if (!view) return;
const token = ++state.imageToken;
cancelWorkflowSequence();
state.pendingLandform = key;
clearTerrainAnnotationNow();
hideWorkflowVisuals();
const nextMode = state.selectedLandform ? state.viewMode : "perspective";
dom.experimentVideo.pause();
const perspectiveProbe = new Image();
const topProbe = new Image();
perspectiveProbe.src = view.image;
topProbe.src = view.topImage;
try {
await Promise.all([decodeImage(perspectiveProbe), decodeImage(topProbe)]);
} catch (error) {
if (token === state.imageToken) {
state.pendingLandform = null;
syncWorkflowPresentation(state.step);
showToast("地貌图片加载失败,请检查对应资源文件");
}
return;
}
if (token !== state.imageToken) return;
state.pendingLandform = null;
state.selectedLandform = key;
state.viewMode = nextMode;
dom.landformImage.src = view.image;
dom.landformImage.alt = view.alt;
dom.landformTopImage.src = view.topImage;
dom.landformTopImage.alt = view.topAlt;
dom.terrainTabs.forEach(function (button) {
const active = button.dataset.landform === key;
button.classList.toggle("is-active", active);
button.setAttribute("aria-pressed", String(active));
});
dom.returnExperiment.hidden = false;
renderObservation(view);
applyLandformView(view, true);
collapsePanelForCompactView();
setPlayButton();
}
async function toggleTopView() {
const view = LANDFORMS[state.selectedLandform];
if (!view) return;
const previousMode = state.viewMode;
const token = ++state.imageToken;
state.pendingLandform = null;
clearTerrainAnnotationNow();
state.viewMode = previousMode === "top" ? "perspective" : "top";
try {
await decodeImage(state.viewMode === "top" ? dom.landformTopImage : dom.landformImage);
} catch (error) {
state.viewMode = previousMode;
showToast("对应视图加载失败,请检查图片资源");
return;
}
if (token !== state.imageToken) return;
applyLandformView(view, true);
collapsePanelForCompactView();
}
function showExperiment() {
cancelWorkflowSequence();
state.imageToken += 1;
state.pendingLandform = null;
state.selectedLandform = null;
state.viewMode = "perspective";
dom.app.classList.remove("is-scanning");
hideWorkflowVisuals();
hideTerrainAnnotation();
dom.landformImage.classList.remove("is-visible", "is-revealing");
dom.landformTopImage.classList.remove("is-visible", "is-revealing");
dom.experimentVideo.classList.add("is-visible");
dom.terrainTabs.forEach(function (button) {
button.classList.remove("is-active");
button.setAttribute("aria-pressed", "false");
});
dom.returnExperiment.hidden = true;
renderObservation(DEFAULT_VIEW);
updateViewToggle();
updateMediaLabel(null);
}
function playVideo() {
dom.experimentVideo.play().then(function () {
setPlayButton();
updateMediaLabel(null);
dom.hintText.textContent = "实验播放中:" + STEP_COPY[state.step].description;
}).catch(function (error) {
if (error && error.name === "AbortError") return;
showToast("视频暂时无法播放,请检查浏览器媒体权限");
});
}
function toggleExperimentPlayback() {
if (state.selectedLandform || state.pendingLandform || state.step >= 2) {
showExperiment();
if (Number.isFinite(dom.experimentVideo.duration) && dom.experimentVideo.duration > 0) {
dom.experimentVideo.currentTime = 0;
} else {
state.pendingStep = 0;
}
renderStep(0);
playVideo();
return;
}
if (!dom.experimentVideo.paused) {
dom.experimentVideo.pause();
return;
}
const duration = dom.experimentVideo.duration;
if (dom.experimentVideo.ended || (Number.isFinite(duration) && dom.experimentVideo.currentTime >= duration - 0.08)) {
dom.experimentVideo.currentTime = 0;
renderStep(0);
}
playVideo();
}
function playFromBeginning() {
showExperiment();
renderStep(0);
if (Number.isFinite(dom.experimentVideo.duration) && dom.experimentVideo.duration > 0) {
dom.experimentVideo.currentTime = 0;
} else {
state.pendingStep = 0;
}
playVideo();
}
function playStep(index) {
const safeIndex = Math.max(0, Math.min(3, Number(index) || 0));
showExperiment();
renderStep(safeIndex);
if (safeIndex <= 1) {
if (Number.isFinite(dom.experimentVideo.duration) && dom.experimentVideo.duration > 0) {
dom.experimentVideo.currentTime = safeIndex === 0 ? 0 : dom.experimentVideo.duration / 2;
} else {
state.pendingStep = safeIndex;
}
playVideo();
return;
}
state.pendingStep = null;
dom.experimentVideo.pause();
setPlayButton();
updateMediaLabel(null);
dom.hintText.textContent = STEP_COPY[safeIndex].title + ":" + STEP_COPY[safeIndex].description;
}
function resetExperience() {
state.pendingStep = null;
dom.experimentVideo.pause();
showExperiment();
renderStep(0);
if (Number.isFinite(dom.experimentVideo.duration) && dom.experimentVideo.duration > 0) {
dom.experimentVideo.currentTime = 0;
} else {
state.pendingStep = 0;
}
dom.progress.style.width = "0%";
dom.hintText.textContent = DEFAULT_VIEW.hint;
setPlayButton();
showToast("已重置到视频首帧");
}
function toggleFullscreen() {
if (!document.fullscreenElement) {
if (!dom.app.requestFullscreen) {
showToast("当前浏览器不支持全屏");
return;
}
dom.app.requestFullscreen().catch(function () { showToast("当前浏览器未允许进入全屏"); });
return;
}
if (document.exitFullscreen) document.exitFullscreen().catch(function () {});
}
dom.experimentVideo.addEventListener("loadeddata", hideLoading, { once: true });
dom.experimentVideo.addEventListener("canplay", hideLoading, { once: true });
dom.experimentVideo.addEventListener("loadedmetadata", function () {
if (state.pendingStep === null) return;
const pending = state.pendingStep;
state.pendingStep = null;
const duration = dom.experimentVideo.duration;
if (Number.isFinite(duration) && duration > 0) {
dom.experimentVideo.currentTime = pending === 0 ? 0 : duration / 2;
renderStep(pending);
}
});
dom.experimentVideo.addEventListener("error", function () {
hideLoading();
showToast("形成交线视频加载失败,请确认“contour-formation.mp4”在当前目录");
});
dom.experimentVideo.addEventListener("play", function () {
setPlayButton();
updateMediaLabel(null);
dom.hintText.textContent = "实验播放中:" + STEP_COPY[state.step].description;
});
dom.experimentVideo.addEventListener("pause", function () {
setPlayButton();
updateMediaLabel(null);
if (!state.selectedLandform && state.step >= 2) {
dom.hintText.textContent = STEP_COPY[state.step].title + ":" + STEP_COPY[state.step].description;
return;
}
if (!dom.experimentVideo.ended && dom.experimentVideo.currentTime > 0.12 && !state.selectedLandform) {
dom.hintText.textContent = "实验已暂停 · 点击“继续实验”恢复播放";
}
});
dom.experimentVideo.addEventListener("ended", function () {
if (
state.selectedLandform ||
state.pendingLandform ||
state.step > 1 ||
!dom.experimentVideo.ended
) return;
dom.progress.style.width = "100%";
beginStaticWorkflowSequence();
});
dom.experimentVideo.addEventListener("timeupdate", function () {
const duration = dom.experimentVideo.duration;
const ratio = Number.isFinite(duration) && duration > 0 ? dom.experimentVideo.currentTime / duration : 0;
dom.progress.style.width = Math.max(0, Math.min(100, ratio * 100)) + "%";
if (!state.selectedLandform && state.step === 0 && ratio >= 0.5) {
renderStep(1);
dom.hintText.textContent = "实验播放中:" + STEP_COPY[1].description;
}
if (!dom.experimentVideo.paused) updateMediaLabel(null);
});
dom.playButton.addEventListener("click", toggleExperimentPlayback);
dom.workflowOpen.addEventListener("click", playFromBeginning);
dom.resetButton.addEventListener("click", resetExperience);
dom.returnExperiment.addEventListener("click", resetExperience);
dom.topViewToggle.addEventListener("click", toggleTopView);
dom.terrainTabs.forEach(function (button) {
button.addEventListener("click", function () { selectLandform(button.dataset.landform); });
});
dom.flowSteps.forEach(function (button) {
button.addEventListener("click", function () { playStep(Number(button.dataset.step)); });
});
dom.fullscreenButton.addEventListener("click", toggleFullscreen);
document.addEventListener("fullscreenchange", function () {
dom.fullscreenLabel.textContent = document.fullscreenElement ? "退出全屏" : "全屏";
});
dom.panelClose.addEventListener("click", function () {
dom.controlPanel.classList.add("is-collapsed");
dom.panelOpen.hidden = false;
});
dom.panelOpen.addEventListener("click", function () {
dom.controlPanel.classList.remove("is-collapsed");
dom.panelOpen.hidden = true;
});
document.addEventListener("keydown", function (event) {
if (event.code === "Space" && !/BUTTON|INPUT|VIDEO/.test(document.activeElement.tagName)) {
event.preventDefault();
toggleExperimentPlayback();
}
if (/^[1-5]$/.test(event.key) && !event.metaKey && !event.ctrlKey && !event.altKey) {
const keys = ["peak", "ridge", "valley", "saddle", "cliff"];
selectLandform(keys[Number(event.key) - 1]);
}
});
window.setTimeout(hideLoading, 7000);
renderStep(0);
renderObservation(DEFAULT_VIEW);
updateViewToggle();
updateMediaLabel(null);
setPlayButton();
window.__GEO_LAB_TEST__ = {
getState: function () {
return {
selectedLandform: state.selectedLandform,
pendingLandform: state.pendingLandform,
viewMode: state.viewMode,
step: state.step,
videoPlaying: !dom.experimentVideo.paused,
videoTime: dom.experimentVideo.currentTime,
videoSource: dom.experimentVideo.currentSrc || dom.experimentVideo.src,
workflowDiagram: !dom.projectionDiagram.hasAttribute("hidden") ? "projection" : !dom.densityDiagram.hasAttribute("hidden") ? "density" : null,
workflowAutoPlaying: state.workflowAutoPlaying,
densityBackground: dom.densityBackground.classList.contains("is-visible"),
scanning: dom.app.classList.contains("is-scanning"),
terrainAnnotation: window.TerrainAnnotation ? window.TerrainAnnotation.getState() : null,
fullscreen: Boolean(document.fullscreenElement)
};
},
selectLandform: selectLandform,
toggleTopView: toggleTopView,
showExperiment: showExperiment,
playStep: playStep,
reset: resetExperience
};
})();
Binary file not shown.

Before

Width:  |  Height:  |  Size: 698 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 961 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 593 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 621 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 947 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 675 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 945 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 622 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 963 KiB

File diff suppressed because it is too large. Load diff
@@ -1,671 +0,0 @@
(function () {
"use strict";
const THREE = window.THREE;
const root = document.getElementById("terrain-annotation");
const canvas = document.getElementById("terrain-annotation-canvas");
const callout = document.getElementById("terrain-callout");
const calloutTitle = document.getElementById("terrain-callout-title");
const calloutCopy = document.getElementById("terrain-callout-copy");
const calloutConnector = document.getElementById("terrain-callout-connector");
const calloutConnectorShape = document.getElementById("terrain-callout-connector-shape");
const stage = document.querySelector(".media-stage");
if (!THREE || !root || !canvas || !callout || !calloutTitle || !calloutCopy || !calloutConnector || !calloutConnectorShape || !stage) return;
const reducedMotion = window.matchMedia("(prefers-reduced-motion: reduce)");
const compactLayout = window.matchMedia("(max-width: 680px)");
const SOURCE_ASPECT = 1586 / 992;
const GUIDE_COLOR = "#f6b21a";
const OUTLINE_COLOR = 0x082742;
const TARGET_OUTER_RADIUS = 20;
const ROLE_STYLES = {
main: { width: 8, outline: 14, opacity: 1, dashed: 0, dashCount: 1, dashRatio: 1, dashSpeed: 0 },
branch: { width: 6.5, outline: 11.5, opacity: 1, dashed: 1, dashCount: 4, dashRatio: 0.62, dashSpeed: 0 },
ring: { width: 6, outline: 10.5, opacity: 1, dashed: 0, dashCount: 1, dashRatio: 1, dashSpeed: 0 },
contour: { width: 4.5, outline: 8.5, opacity: 1, dashed: 0, dashCount: 1, dashRatio: 1, dashSpeed: 0 },
bracket: { width: 5.5, outline: 10, opacity: 1, dashed: 1, dashCount: 4, dashRatio: 0.62, dashSpeed: 0 }
};
const ANNOTATIONS = {
peak: {
title: "山峰 · 最高中心",
copy: "闭合等高线由外向内数值升高,中心位置为山峰。",
color: GUIDE_COLOR,
perspective: {
traces: [
{ role: "main", arrow: true, points: [[0.628, 0.575], [0.650, 0.455], [0.670, 0.280], [0.709, 0.143]] }
],
target: [0.709, 0.143],
placement: { side: "right", dx: 34, dy: 24 }
},
top: {
traces: [
{ role: "main", arrow: true, points: [[0.575, 0.645], [0.610, 0.555], [0.645, 0.485], [0.668, 0.449]] }
],
target: [0.668, 0.449],
placement: { side: "right", dx: 34, dy: -10 }
}
},
ridge: {
title: "山脊 · 分水脊线",
copy: "等高线向低处凸出,脊线两侧水流向外分开。",
color: GUIDE_COLOR,
perspective: {
traces: [
{ role: "main", arrow: true, points: [[0.765, 0.245], [0.720, 0.365], [0.675, 0.500], [0.625, 0.645]] },
{ role: "branch", arrow: true, points: [[0.675, 0.500], [0.635, 0.535], [0.595, 0.565]] },
{ role: "branch", arrow: true, points: [[0.675, 0.500], [0.715, 0.535], [0.755, 0.570]] }
],
target: [0.675, 0.500],
placement: { side: "left", dx: -34, dy: -85 }
},
top: {
traces: [
{ role: "main", arrow: true, points: [[0.690, 0.270], [0.655, 0.395], [0.620, 0.520], [0.590, 0.650]] },
{ role: "branch", arrow: true, points: [[0.620, 0.520], [0.582, 0.545], [0.548, 0.575]] },
{ role: "branch", arrow: true, points: [[0.620, 0.520], [0.658, 0.548], [0.695, 0.580]] }
],
target: [0.620, 0.520],
placement: { side: "left", dx: -34, dy: -85 }
}
},
valley: {
title: "山谷 · 汇水谷线",
copy: "V形尖端指向上游,水流沿谷底向下游汇集。",
color: GUIDE_COLOR,
perspective: {
traces: [
{ role: "main", arrow: true, points: [[0.690, 0.410], [0.678, 0.520], [0.676, 0.550], [0.660, 0.650], [0.640, 0.790]] },
{ role: "branch", arrow: true, points: [[0.590, 0.560], [0.630, 0.560], [0.676, 0.550]] },
{ role: "branch", arrow: true, points: [[0.750, 0.560], [0.710, 0.560], [0.676, 0.550]] }
],
target: [0.676, 0.550],
placement: { side: "right", dx: 34, dy: -80 }
},
top: {
traces: [
{ role: "main", arrow: true, points: [[0.600, 0.355], [0.565, 0.470], [0.525, 0.585], [0.470, 0.690]] },
{ role: "branch", arrow: true, points: [[0.455, 0.520], [0.490, 0.555], [0.525, 0.585]] },
{ role: "branch", arrow: true, points: [[0.600, 0.510], [0.565, 0.550], [0.525, 0.585]] }
],
target: [0.525, 0.585],
placement: { side: "right", dx: 34, dy: 70 }
}
},
saddle: {
title: "鞍部 · 两峰低口",
copy: "两组闭合等高线之间的低口,就是鞍部。",
color: GUIDE_COLOR,
perspective: {
traces: [
{ role: "main", points: [[0.625, 0.425], [0.675, 0.465], [0.725, 0.420]] }
],
target: [0.675, 0.465],
placement: { side: "below", dx: 0, dy: 38 }
},
top: {
traces: [
{ role: "main", points: [[0.515, 0.475], [0.560, 0.505], [0.610, 0.475]] }
],
target: [0.560, 0.505],
placement: { side: "below", dx: 0, dy: 38 }
}
},
cliff: {
title: "陡崖 · 密集重合带",
copy: "等高线极密集或重合,表示此处坡度陡峭。",
color: GUIDE_COLOR,
perspective: {
traces: [
{ role: "contour", points: [[0.535, 0.345], [0.565, 0.352], [0.590, 0.360]] },
{ role: "contour", points: [[0.532, 0.390], [0.562, 0.398], [0.590, 0.405]] },
{ role: "contour", points: [[0.530, 0.435], [0.560, 0.443], [0.590, 0.452]] },
{ role: "main", arrow: true, points: [[0.595, 0.305], [0.590, 0.405], [0.598, 0.510]] }
],
target: [0.590, 0.405],
placement: { side: "right", dx: 34, dy: 0 }
},
top: {
traces: [
{ role: "main", arrow: true, points: [[0.535, 0.560], [0.585, 0.520], [0.635, 0.480]] },
{ role: "contour", points: [[0.555, 0.455], [0.575, 0.515], [0.595, 0.575]] },
{ role: "contour", points: [[0.590, 0.435], [0.610, 0.495], [0.630, 0.555]] }
],
target: [0.585, 0.520],
placement: { side: "below", dx: 0, dy: 70 }
}
}
};
let renderer;
let scene;
let camera;
let annotationGroup;
let aspect = 1;
let stageHeight = 1;
let animationFrame = 0;
let revealStart = 0;
let calloutTimer = 0;
let hideTimer = 0;
let currentKey = null;
let currentMode = "perspective";
let buildToken = 0;
let animatedMaterials = [];
let revealGeometries = [];
let pulseMeshes = [];
let delayedMarkers = [];
let runnerDots = [];
try {
renderer = new THREE.WebGLRenderer({ canvas: canvas, alpha: true, antialias: true, powerPreference: "high-performance" });
renderer.setClearColor(0x000000, 0);
renderer.setPixelRatio(Math.min(window.devicePixelRatio || 1, 1.75));
scene = new THREE.Scene();
camera = new THREE.OrthographicCamera(-1, 1, 1, -1, 0.1, 10);
camera.position.z = 4;
} catch (error) {
root.dataset.renderer = "unavailable";
return;
}
function sourceToScreen(point) {
let renderedWidth = 1;
let renderedHeight = 1;
let offsetX = 0;
let offsetY = 0;
if (compactLayout.matches) {
if (aspect >= SOURCE_ASPECT) {
renderedWidth = SOURCE_ASPECT / aspect;
offsetX = (1 - renderedWidth) / 2;
} else {
renderedHeight = aspect / SOURCE_ASPECT;
offsetY = (1 - renderedHeight) / 2;
}
} else {
if (aspect >= SOURCE_ASPECT) {
renderedHeight = aspect / SOURCE_ASPECT;
offsetY = (1 - renderedHeight) / 2;
} else {
renderedWidth = SOURCE_ASPECT / aspect;
offsetX = (1 - renderedWidth) / 2;
}
}
return [offsetX + point[0] * renderedWidth, offsetY + point[1] * renderedHeight];
}
function toWorld(point) {
const screenPoint = sourceToScreen(point);
return new THREE.Vector3((screenPoint[0] - 0.5) * 2 * aspect, (0.5 - screenPoint[1]) * 2, 0);
}
function getVisualScale() {
return Math.max(0.72, Math.min(1, stage.clientWidth / 1200));
}
function disposeMaterial(material) {
if (Array.isArray(material)) material.forEach(disposeMaterial);
else if (material && typeof material.dispose === "function") material.dispose();
}
function clearAnnotation() {
if (!annotationGroup) return;
annotationGroup.traverse(function (object) {
if (object.geometry) object.geometry.dispose();
if (object.material) disposeMaterial(object.material);
});
scene.remove(annotationGroup);
annotationGroup = null;
animatedMaterials = [];
revealGeometries = [];
pulseMeshes = [];
delayedMarkers = [];
runnerDots = [];
}
function createRibbonGeometry(samples, widthInPixels) {
const positions = [];
const uvs = [];
const indices = [];
const halfWidth = widthInPixels / Math.max(1, stageHeight);
samples.forEach(function (point, index) {
const previous = samples[Math.max(0, index - 1)];
const next = samples[Math.min(samples.length - 1, index + 1)];
const tangentX = next.x - previous.x;
const tangentY = next.y - previous.y;
const length = Math.hypot(tangentX, tangentY) || 1;
const normalX = -tangentY / length;
const normalY = tangentX / length;
const progress = index / Math.max(1, samples.length - 1);
positions.push(point.x + normalX * halfWidth, point.y + normalY * halfWidth, point.z);
positions.push(point.x - normalX * halfWidth, point.y - normalY * halfWidth, point.z);
uvs.push(progress, 0, progress, 1);
if (index < samples.length - 1) {
const base = index * 2;
indices.push(base, base + 1, base + 2, base + 1, base + 3, base + 2);
}
});
const geometry = new THREE.BufferGeometry();
geometry.setAttribute("position", new THREE.Float32BufferAttribute(positions, 3));
geometry.setAttribute("uv", new THREE.Float32BufferAttribute(uvs, 2));
geometry.setIndex(indices);
geometry.computeBoundingSphere();
return geometry;
}
function makeLineMaterial(color, style) {
return new THREE.ShaderMaterial({
uniforms: {
uTime: { value: 0 },
uColor: { value: new THREE.Color(color) },
uOpacity: { value: style.opacity },
uMotion: { value: reducedMotion.matches ? 0 : 1 },
uDashed: { value: style.dashed },
uDashCount: { value: style.dashCount },
uDashRatio: { value: style.dashRatio },
uDashSpeed: { value: style.dashSpeed }
},
vertexShader: [
"varying vec2 vUv;",
"void main() {",
" vUv = uv;",
" gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);",
"}"
].join("\n"),
fragmentShader: [
"uniform float uTime;",
"uniform vec3 uColor;",
"uniform float uOpacity;",
"uniform float uMotion;",
"uniform float uDashed;",
"uniform float uDashCount;",
"uniform float uDashRatio;",
"uniform float uDashSpeed;",
"varying vec2 vUv;",
"void main() {",
" float edge = 1.0 - smoothstep(0.43, 0.50, abs(vUv.y - 0.5));",
" float dashPhase = fract(vUv.x * uDashCount - uTime * uDashSpeed * uMotion);",
" float dash = 1.0 - smoothstep(uDashRatio - 0.04, uDashRatio + 0.04, dashPhase);",
" float pattern = mix(1.0, dash, uDashed);",
" float alpha = uOpacity * edge * pattern;",
" gl_FragColor = vec4(uColor, alpha);",
"}"
].join("\n"),
transparent: true,
depthTest: false,
depthWrite: false,
blending: THREE.NormalBlending
});
}
function createArrow(points, color, sizeInPixels, delay, stopBeforePixels) {
const end = toWorld(points[points.length - 1]);
const before = toWorld(points[points.length - 2]);
const direction = end.clone().sub(before).normalize();
const angle = Math.atan2(direction.y, direction.x);
const unit = 2 / Math.max(1, stageHeight);
const visualScale = getVisualScale();
const scaledSize = sizeInPixels * visualScale;
const arrowPosition = end.clone().addScaledVector(direction, -(stopBeforePixels || 0) * visualScale * unit);
function createArrowGeometry(pixelSize) {
const size = pixelSize * unit;
const geometry = new THREE.BufferGeometry();
geometry.setAttribute("position", new THREE.Float32BufferAttribute([
0, 0, 0,
-size * 1.90, size * 0.88, 0,
-size * 1.90, -size * 0.88, 0
], 3));
return geometry;
}
const outlineMaterial = new THREE.MeshBasicMaterial({ color: OUTLINE_COLOR, transparent: true, opacity: 1, depthTest: false, depthWrite: false });
const material = new THREE.MeshBasicMaterial({ color: color, transparent: true, opacity: 1, depthTest: false, depthWrite: false });
const outline = new THREE.Mesh(createArrowGeometry(scaledSize + 2.5 * visualScale), outlineMaterial);
const arrow = new THREE.Mesh(createArrowGeometry(scaledSize), material);
outline.position.copy(arrowPosition).addScaledVector(direction, 1.25 * visualScale * unit);
arrow.position.copy(arrowPosition);
outline.rotation.z = angle;
arrow.rotation.z = angle;
outline.renderOrder = 40;
arrow.renderOrder = 41;
annotationGroup.add(outline, arrow);
delayedMarkers.push({ mesh: outline, delay: delay + 0.46 });
delayedMarkers.push({ mesh: arrow, delay: delay + 0.46 });
}
function createRunnerDots(curve, delay, count) {
const pixelUnit = 2 / Math.max(1, stageHeight);
const visualScale = getVisualScale();
const phases = count === 1 ? [0.18] : count === 2 ? [0.18, 0.70] : [0.12, 0.45, 0.78];
phases.forEach(function (phase, index) {
const glowMaterial = new THREE.MeshBasicMaterial({
color: 0xffffff,
transparent: true,
opacity: 0.28,
depthTest: false,
depthWrite: false,
blending: THREE.AdditiveBlending
});
const dotMaterial = new THREE.MeshBasicMaterial({ color: 0xffffff, transparent: true, opacity: 1, depthTest: false, depthWrite: false });
const glow = new THREE.Mesh(new THREE.CircleGeometry(11 * visualScale * pixelUnit, 40), glowMaterial);
const dot = new THREE.Mesh(new THREE.CircleGeometry(7.5 * visualScale * pixelUnit, 40), dotMaterial);
const position = curve.getPointAt(phase);
glow.position.copy(position);
dot.position.copy(position);
glow.renderOrder = 44;
dot.renderOrder = 45;
glow.visible = false;
dot.visible = false;
annotationGroup.add(glow, dot);
runnerDots.push({ glow: glow, dot: dot, curve: curve, phase: phase, delay: delay + 0.18, pulseOffset: index * 1.8 });
});
}
function createTrace(trace, color, index, target) {
const style = ROLE_STYLES[trace.role] || ROLE_STYLES.main;
const worldPoints = trace.points.map(toWorld);
const curve = new THREE.CatmullRomCurve3(worldPoints, Boolean(trace.closed), "centripetal", 0.5);
const pathLengthPixels = curve.getLength() * stageHeight / 2;
const samples = curve.getSpacedPoints(Math.max(36, trace.points.length * 12));
const visualScale = getVisualScale();
const outlineGeometry = createRibbonGeometry(samples, style.outline * visualScale);
const lineGeometry = createRibbonGeometry(samples, style.width * visualScale);
const outlineMaterial = makeLineMaterial(OUTLINE_COLOR, style);
const lineMaterial = makeLineMaterial(color, style);
const outline = new THREE.Mesh(outlineGeometry, outlineMaterial);
const line = new THREE.Mesh(lineGeometry, lineMaterial);
const isMain = trace.role === "main";
outline.renderOrder = isMain ? 30 : 20;
line.renderOrder = isMain ? 31 : 21;
annotationGroup.add(outline, line);
animatedMaterials.push(outlineMaterial, lineMaterial);
const delay = index * 0.075;
if (trace.role === "main") createRunnerDots(curve, delay, pathLengthPixels < 180 ? 1 : pathLengthPixels < 320 ? 2 : 3);
revealGeometries.push({ geometry: outlineGeometry, count: outlineGeometry.index.count, delay: delay });
revealGeometries.push({ geometry: lineGeometry, count: lineGeometry.index.count, delay: delay });
if (trace.arrow && !trace.closed) {
const endPoint = trace.points[trace.points.length - 1];
const endsAtTarget = target && Math.hypot(endPoint[0] - target[0], endPoint[1] - target[1]) < 0.002;
const arrowScale = Math.max(0.82, Math.min(1, pathLengthPixels / 240));
createArrow(trace.points, color, (trace.role === "branch" ? 14 : 15) * arrowScale, delay, endsAtTarget ? TARGET_OUTER_RADIUS + 4 : 0);
}
}
function createTarget(point, color) {
const position = toWorld(point);
const pixelUnit = 2 / Math.max(1, stageHeight);
const visualScale = getVisualScale();
const halo = new THREE.Mesh(
new THREE.CircleGeometry(25 * visualScale * pixelUnit, 64),
new THREE.MeshBasicMaterial({ color: color, transparent: true, opacity: 0.20, depthTest: false, depthWrite: false, blending: THREE.AdditiveBlending })
);
const outer = new THREE.Mesh(
new THREE.CircleGeometry(TARGET_OUTER_RADIUS * visualScale * pixelUnit, 64),
new THREE.MeshBasicMaterial({ color: OUTLINE_COLOR, transparent: true, opacity: 1, depthTest: false, depthWrite: false })
);
const gold = new THREE.Mesh(
new THREE.CircleGeometry(17.5 * visualScale * pixelUnit, 64),
new THREE.MeshBasicMaterial({ color: color, transparent: true, opacity: 1, depthTest: false, depthWrite: false })
);
const white = new THREE.Mesh(
new THREE.CircleGeometry(13.5 * visualScale * pixelUnit, 64),
new THREE.MeshBasicMaterial({ color: 0xffffff, transparent: true, opacity: 1, depthTest: false, depthWrite: false })
);
const inner = new THREE.Mesh(
new THREE.CircleGeometry(10 * visualScale * pixelUnit, 56),
new THREE.MeshBasicMaterial({ color: OUTLINE_COLOR, transparent: true, opacity: 1, depthTest: false, depthWrite: false })
);
const core = new THREE.Mesh(
new THREE.CircleGeometry(7.5 * visualScale * pixelUnit, 56),
new THREE.MeshBasicMaterial({ color: color, transparent: true, opacity: 1, depthTest: false, depthWrite: false })
);
[halo, outer, gold, white, inner, core].forEach(function (mesh, index) {
mesh.position.copy(position);
mesh.renderOrder = 49 + index;
annotationGroup.add(mesh);
});
pulseMeshes.push(halo);
}
function updateCallout(definition, view) {
const targetScreen = sourceToScreen(view.target);
const placement = view.placement;
calloutTitle.textContent = definition.title + (currentMode === "top" ? " · 俯视判读" : "");
calloutCopy.textContent = definition.copy;
const width = stage.clientWidth;
const height = stage.clientHeight;
const targetX = targetScreen[0] * width;
const targetY = targetScreen[1] * height;
const cardWidth = callout.offsetWidth || Math.min(width <= 680 ? 210 : width <= 920 ? 250 : 280, width - 28);
const cardHeight = callout.offsetHeight || 88;
let side = placement.side;
let x = targetX + placement.dx;
let y = targetY + placement.dy;
const targetGap = TARGET_OUTER_RADIUS * getVisualScale() + 18;
const horizontalGap = Math.max(Math.abs(placement.dx), targetGap);
const verticalGap = Math.max(Math.abs(placement.dy), targetGap);
if (side === "right") x = targetX + horizontalGap;
else if (side === "left") x = targetX - horizontalGap;
else if (side === "below") y = targetY + verticalGap;
else if (side === "above") y = targetY - verticalGap;
if (side === "right" && x + cardWidth > width - 14) {
side = "left";
x = targetX - horizontalGap;
} else if (side === "left" && x - cardWidth < 14) {
side = "right";
x = targetX + horizontalGap;
} else if (side === "below" && y + cardHeight > height - 14) {
side = "above";
y = targetY - verticalGap;
} else if (side === "above" && y - cardHeight < 14) {
side = "below";
y = targetY + verticalGap;
}
if (side === "right" || side === "left") {
const horizontalMargin = compactLayout.matches ? 0 : 14;
if (side === "right") x = Math.max(horizontalMargin, Math.min(width - cardWidth - horizontalMargin, x));
else x = Math.max(cardWidth + horizontalMargin, Math.min(width - horizontalMargin, x));
y = Math.max(cardHeight / 2 + 14, Math.min(height - cardHeight / 2 - 14, y));
} else {
x = Math.max(cardWidth / 2 + 14, Math.min(width - cardWidth / 2 - 14, x));
}
const connectorBaseHalf = 28 * getVisualScale();
let anchorX = x;
let anchorY = y;
let baseOne;
let baseTwo;
if (side === "right" || side === "left") {
const verticalLimit = Math.max(0, cardHeight / 2 - connectorBaseHalf - 4);
anchorY = y + Math.max(-verticalLimit, Math.min(verticalLimit, targetY - y));
baseOne = [anchorX, anchorY - connectorBaseHalf];
baseTwo = [anchorX, anchorY + connectorBaseHalf];
} else {
const horizontalLimit = Math.max(0, cardWidth / 2 - connectorBaseHalf - 4);
anchorX = x + Math.max(-horizontalLimit, Math.min(horizontalLimit, targetX - x));
baseOne = [anchorX - connectorBaseHalf, anchorY];
baseTwo = [anchorX + connectorBaseHalf, anchorY];
}
const connectorX = anchorX - targetX;
const connectorY = anchorY - targetY;
const connectorLength = Math.hypot(connectorX, connectorY) || 1;
const tipRadius = TARGET_OUTER_RADIUS * getVisualScale() * 0.72;
const tipX = targetX + connectorX / connectorLength * tipRadius;
const tipY = targetY + connectorY / connectorLength * tipRadius;
calloutConnector.setAttribute("viewBox", "0 0 " + width + " " + height);
calloutConnectorShape.setAttribute(
"points",
tipX.toFixed(1) + "," + tipY.toFixed(1) + " " +
baseOne[0].toFixed(1) + "," + baseOne[1].toFixed(1) + " " +
baseTwo[0].toFixed(1) + "," + baseTwo[1].toFixed(1)
);
const pointerInset = 32;
const pointerOffsetX = Math.max(-cardWidth / 2 + pointerInset, Math.min(cardWidth / 2 - pointerInset, targetX - x));
const pointerOffsetY = Math.max(-cardHeight / 2 + pointerInset, Math.min(cardHeight / 2 - pointerInset, targetY - y));
root.style.setProperty("--callout-x", x + "px");
root.style.setProperty("--callout-y", y + "px");
root.style.setProperty("--pointer-offset-x", pointerOffsetX + "px");
root.style.setProperty("--pointer-offset-y", pointerOffsetY + "px");
root.dataset.side = side;
root.dataset.tone = currentKey === "cliff" ? "warning" : "default";
}
function buildAnnotation(key, mode, animate) {
const definition = ANNOTATIONS[key];
if (!definition) return;
const view = definition[mode === "top" ? "top" : "perspective"];
clearAnnotation();
annotationGroup = new THREE.Group();
scene.add(annotationGroup);
view.traces.forEach(function (trace, index) { createTrace(trace, definition.color, index, view.target); });
createTarget(view.target, definition.color);
updateCallout(definition, view);
revealGeometries.forEach(function (item) {
item.geometry.setDrawRange(0, animate && !reducedMotion.matches ? 0 : item.count);
});
delayedMarkers.forEach(function (item) { item.mesh.visible = !animate || reducedMotion.matches; });
runnerDots.forEach(function (item) {
const position = item.curve.getPointAt(item.phase);
item.glow.position.copy(position);
item.dot.position.copy(position);
item.glow.visible = !animate || reducedMotion.matches;
item.dot.visible = !animate || reducedMotion.matches;
});
revealStart = performance.now() - (animate && !reducedMotion.matches ? 0 : 760);
}
function resize() {
const width = Math.max(1, stage.clientWidth);
const height = Math.max(1, stage.clientHeight);
const nextAspect = width / height;
const sizeChanged = Math.abs(nextAspect - aspect) > 0.001 || Math.abs(height - stageHeight) > 1;
aspect = nextAspect;
stageHeight = height;
renderer.setSize(width, height, false);
camera.left = -nextAspect;
camera.right = nextAspect;
camera.top = 1;
camera.bottom = -1;
camera.updateProjectionMatrix();
if (sizeChanged && currentKey && !root.hidden) buildAnnotation(currentKey, currentMode, false);
renderer.render(scene, camera);
}
function renderFrame(now) {
if (!currentKey || root.hidden || document.hidden) {
animationFrame = 0;
return;
}
const seconds = now * 0.001;
const elapsed = (now - revealStart) / 760;
animatedMaterials.forEach(function (material) {
material.uniforms.uTime.value = seconds;
material.uniforms.uMotion.value = reducedMotion.matches ? 0 : 1;
});
if (!reducedMotion.matches) {
revealGeometries.forEach(function (item) {
const progress = Math.max(0, Math.min(1, (elapsed - item.delay) / 0.62));
const eased = 1 - Math.pow(1 - progress, 3);
const count = Math.floor(item.count * eased / 6) * 6;
item.geometry.setDrawRange(0, Math.max(0, count));
});
delayedMarkers.forEach(function (item) { item.mesh.visible = elapsed >= item.delay; });
const motionSeconds = Math.max(0, (now - revealStart) * 0.001);
runnerDots.forEach(function (item) {
const visible = elapsed >= item.delay;
item.glow.visible = visible;
item.dot.visible = visible;
if (!visible) return;
const position = item.curve.getPointAt((item.phase + motionSeconds * 0.065) % 1);
item.glow.position.copy(position);
item.dot.position.copy(position);
item.glow.scale.setScalar(1 + Math.sin(seconds * 3.6 + item.pulseOffset) * 0.14);
});
const pulse = 1 + Math.sin(seconds * 3.2) * 0.10;
pulseMeshes.forEach(function (mesh) { mesh.scale.setScalar(pulse); });
}
renderer.render(scene, camera);
if (reducedMotion.matches) {
animationFrame = 0;
return;
}
animationFrame = window.requestAnimationFrame(renderFrame);
}
function startRendering() {
if (!animationFrame) animationFrame = window.requestAnimationFrame(renderFrame);
}
function show(key, mode) {
if (!ANNOTATIONS[key]) return;
window.clearTimeout(calloutTimer);
window.clearTimeout(hideTimer);
buildToken += 1;
currentKey = key;
currentMode = mode === "top" ? "top" : "perspective";
root.hidden = false;
root.classList.remove("is-visible", "is-callout-visible");
resize();
buildAnnotation(currentKey, currentMode, true);
const token = buildToken;
window.requestAnimationFrame(function () {
if (token === buildToken) root.classList.add("is-visible");
});
calloutTimer = window.setTimeout(function () {
if (token === buildToken) root.classList.add("is-callout-visible");
}, reducedMotion.matches ? 0 : 430);
startRendering();
}
function hide(immediate) {
buildToken += 1;
currentKey = null;
window.clearTimeout(calloutTimer);
window.clearTimeout(hideTimer);
root.classList.remove("is-visible", "is-callout-visible");
if (immediate) {
root.hidden = true;
clearAnnotation();
if (animationFrame) {
window.cancelAnimationFrame(animationFrame);
animationFrame = 0;
}
return;
}
hideTimer = window.setTimeout(function () {
if (!currentKey) {
root.hidden = true;
clearAnnotation();
}
}, 220);
}
if (typeof ResizeObserver === "function") {
const observer = new ResizeObserver(resize);
observer.observe(stage);
} else {
window.addEventListener("resize", resize, { passive: true });
}
const handleMotionPreference = function () {
if (currentKey) {
buildAnnotation(currentKey, currentMode, false);
startRendering();
}
};
if (typeof reducedMotion.addEventListener === "function") reducedMotion.addEventListener("change", handleMotionPreference);
else if (typeof reducedMotion.addListener === "function") reducedMotion.addListener(handleMotionPreference);
document.addEventListener("visibilitychange", function () {
if (!document.hidden && currentKey) startRendering();
});
window.TerrainAnnotation = {
show: show,
hide: hide,
getState: function () {
return { key: currentKey, mode: currentMode, renderer: "three-r" + THREE.REVISION, side: root.dataset.side || null };
}
};
})();
File diff suppressed because it is too large. Load diff
Binary file not shown.

Before

Width:  |  Height:  |  Size: 701 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 1.0 MiB

-333
View File
@@ -1,333 +0,0 @@
<!doctype html>
<html lang="zh-CN">
<head><meta http-equiv="Content-Security-Policy" content="default-src 'self' file: data: blob:; connect-src 'self' file: data: blob:; img-src 'self' file: data: blob:; media-src 'self' file: data: blob:; font-src 'self' data:; style-src 'unsafe-inline' 'self' file: data:; script-src 'unsafe-inline' 'self' file: data: blob:; base-uri 'none'; form-action 'none'; frame-src 'none'; object-src 'none'; worker-src 'none'">
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
<meta name="theme-color" content="#d7ecff">
<title>等高线地形——五大典型地貌判读</title>
<link rel="stylesheet" href="assets/style.css">
</head>
<body>
<main class="app-shell" id="app-shell">
<section class="media-stage" aria-label="等高线实验观察区">
<video
class="stage-media stage-video is-visible"
id="experiment-video"
src="assets/contour-formation.mp4"
preload="auto"
playsinline
aria-label="等高线形成交线实验视频"
></video>
<img
class="stage-media stage-image workflow-step-background"
id="density-background"
src="assets/density-background.jpg"
alt="山体两侧以疏密不同的等高线对比坡度"
decoding="async"
>
<img class="stage-media stage-image" id="landform-image" alt="" decoding="async">
<img class="stage-media stage-image stage-top-image" id="landform-top-image" alt="" decoding="async">
<div class="media-shade" aria-hidden="true"></div>
<div class="scan-effect" id="scan-effect" aria-hidden="true">
<span class="scan-grid"></span>
<span class="scan-beam"></span>
</div>
<svg
class="workflow-diagram workflow-diagram--projection"
id="projection-diagram"
viewBox="0 0 300 455"
role="img"
aria-labelledby="projection-diagram-title projection-diagram-description"
hidden
>
<title id="projection-diagram-title">垂直投影</title>
<desc id="projection-diagram-description">立体山体上的多层等高交线沿垂线投影到同一平面,形成平面等高线。</desc>
<defs>
<linearGradient id="projection-card-fill" x1="0" y1="0" x2="1" y2="1">
<stop offset="0" stop-color="#ffffff" stop-opacity=".94"/>
<stop offset="1" stop-color="#edf7ff" stop-opacity=".88"/>
</linearGradient>
<linearGradient id="projection-beam" gradientUnits="userSpaceOnUse" x1="0" y1="60" x2="0" y2="340">
<stop offset="0" stop-color="#26c7ff" stop-opacity=".18"/>
<stop offset=".42" stop-color="#1089ff" stop-opacity=".72"/>
<stop offset="1" stop-color="#126fff" stop-opacity=".96"/>
</linearGradient>
<linearGradient id="projection-layer-stroke" x1="0" y1="0" x2="1" y2="0">
<stop offset="0" stop-color="#3a7fff"/>
<stop offset=".5" stop-color="#31d8ff"/>
<stop offset="1" stop-color="#3a7fff"/>
</linearGradient>
<linearGradient id="projection-plane-fill" x1="0" y1="0" x2="0" y2="1">
<stop offset="0" stop-color="#eaf7ff" stop-opacity=".64"/>
<stop offset="1" stop-color="#b9ddff" stop-opacity=".20"/>
</linearGradient>
<filter id="projection-card-shadow" x="-30%" y="-20%" width="160%" height="160%">
<feDropShadow dx="0" dy="14" stdDeviation="14" flood-color="#052b50" flood-opacity=".20"/>
</filter>
<filter id="projection-glow" x="-80%" y="-80%" width="260%" height="260%">
<feGaussianBlur stdDeviation="2.6" result="blur"/>
<feMerge><feMergeNode in="blur"/><feMergeNode in="SourceGraphic"/></feMerge>
</filter>
<marker id="projection-arrow" viewBox="0 0 8 8" refX="7" refY="4" markerWidth="6" markerHeight="6" orient="auto">
<path d="M1 1 7 4 1 7" fill="none" stroke="#147dff" stroke-width="1.4" stroke-linecap="round" stroke-linejoin="round"/>
</marker>
</defs>
<rect class="diagram-card" x="3" y="3" width="294" height="449" rx="17" fill="url(#projection-card-fill)" filter="url(#projection-card-shadow)"/>
<text class="diagram-heading" x="20" y="38">垂直投影</text>
<g class="projection-stack" filter="url(#projection-glow)">
<ellipse class="projection-layer" style="--i:0" cx="150" cy="64" rx="43" ry="10"/>
<ellipse class="projection-layer" style="--i:1" cx="150" cy="84" rx="58" ry="12"/>
<ellipse class="projection-layer" style="--i:2" cx="150" cy="105" rx="75" ry="13"/>
<ellipse class="projection-layer" style="--i:3" cx="150" cy="126" rx="94" ry="15"/>
<ellipse class="projection-layer" style="--i:4" cx="150" cy="148" rx="111" ry="16"/>
<ellipse class="projection-layer" style="--i:5" cx="150" cy="170" rx="126" ry="18"/>
</g>
<g class="projection-columns">
<line class="projection-column" x1="49" y1="166" x2="49" y2="347" marker-end="url(#projection-arrow)"/>
<line class="projection-column" x1="65" y1="154" x2="65" y2="331" marker-end="url(#projection-arrow)"/>
<line class="projection-column" x1="83" y1="139" x2="83" y2="323" marker-end="url(#projection-arrow)"/>
<line class="projection-column" x1="103" y1="121" x2="103" y2="331" marker-end="url(#projection-arrow)"/>
<line class="projection-column" x1="125" y1="101" x2="125" y2="338" marker-end="url(#projection-arrow)"/>
<line class="projection-column" x1="150" y1="73" x2="150" y2="347" marker-end="url(#projection-arrow)"/>
<line class="projection-column" x1="175" y1="101" x2="175" y2="338" marker-end="url(#projection-arrow)"/>
<line class="projection-column" x1="197" y1="121" x2="197" y2="331" marker-end="url(#projection-arrow)"/>
<line class="projection-column" x1="217" y1="139" x2="217" y2="323" marker-end="url(#projection-arrow)"/>
<line class="projection-column" x1="235" y1="154" x2="235" y2="331" marker-end="url(#projection-arrow)"/>
<line class="projection-column" x1="251" y1="166" x2="251" y2="347" marker-end="url(#projection-arrow)"/>
<g class="projection-crossings" filter="url(#projection-glow)">
<circle cx="65" cy="154" r="2.4"/><circle cx="83" cy="139" r="2.4"/><circle cx="103" cy="121" r="2.4"/>
<circle cx="125" cy="101" r="2.4"/><circle cx="150" cy="73" r="2.4"/><circle cx="175" cy="101" r="2.4"/>
<circle cx="197" cy="121" r="2.4"/><circle cx="217" cy="139" r="2.4"/><circle cx="235" cy="154" r="2.4"/>
</g>
</g>
<g class="projection-plane">
<polygon points="34,300 266,300 285,395 15,395" fill="url(#projection-plane-fill)" stroke="#7fa6d4" stroke-width="1.1"/>
<path class="projection-grid" d="M30 318h240M26 340h248M22 365h256M19 383h262M63 300 48 395M91 300l-8 95M121 300l-3 95M150 300v95M179 300l3 95M209 300l8 95M237 300l15 95"/>
<ellipse class="projection-contour" style="--i:0" cx="150" cy="347" rx="101" ry="43"/>
<ellipse class="projection-contour" style="--i:1" cx="150" cy="347" rx="79" ry="34"/>
<ellipse class="projection-contour" style="--i:2" cx="150" cy="347" rx="59" ry="27"/>
<ellipse class="projection-contour" style="--i:3" cx="150" cy="347" rx="42" ry="20"/>
<ellipse class="projection-contour" style="--i:4" cx="150" cy="347" rx="24" ry="12"/>
<ellipse class="projection-contour" style="--i:5" cx="150" cy="347" rx="11" ry="6"/>
<g class="projection-landings" filter="url(#projection-glow)">
<circle cx="49" cy="347" r="2.8"/><circle cx="65" cy="331" r="2.8"/><circle cx="83" cy="323" r="2.8"/>
<circle cx="103" cy="331" r="2.8"/><circle cx="125" cy="338" r="2.8"/><circle cx="150" cy="347" r="2.8"/>
<circle cx="175" cy="338" r="2.8"/><circle cx="197" cy="331" r="2.8"/><circle cx="217" cy="323" r="2.8"/>
<circle cx="235" cy="331" r="2.8"/><circle cx="251" cy="347" r="2.8"/>
</g>
</g>
<text class="diagram-footer" x="150" y="431" text-anchor="middle">立体交线 → 平面等高线</text>
</svg>
<svg
class="workflow-diagram workflow-diagram--density"
id="density-diagram"
viewBox="0 0 368 283"
role="img"
aria-labelledby="density-diagram-title density-diagram-description"
hidden
>
<title id="density-diagram-title">疏密判坡</title>
<desc id="density-diagram-description">等高线稀疏的一侧坡缓,等高线密集的一侧坡陡。</desc>
<defs>
<linearGradient id="density-card-fill" x1="0" y1="0" x2="1" y2="1">
<stop offset="0" stop-color="#ffffff" stop-opacity=".94"/>
<stop offset="1" stop-color="#edf7ff" stop-opacity=".88"/>
</linearGradient>
<linearGradient id="density-contour-stroke" gradientUnits="userSpaceOnUse" x1="95" y1="0" x2="320" y2="0">
<stop offset="0" stop-color="#1587ff"/>
<stop offset=".50" stop-color="#3e95ff"/>
<stop offset=".64" stop-color="#f0a43d"/>
<stop offset="1" stop-color="#ff8517"/>
</linearGradient>
<filter id="density-card-shadow" x="-30%" y="-35%" width="160%" height="180%">
<feDropShadow dx="0" dy="14" stdDeviation="14" flood-color="#052b50" flood-opacity=".20"/>
</filter>
<filter id="density-dot-glow" x="-120%" y="-120%" width="340%" height="340%">
<feGaussianBlur stdDeviation="3" result="blur"/>
<feMerge><feMergeNode in="blur"/><feMergeNode in="SourceGraphic"/></feMerge>
</filter>
<path id="density-contour-shape" d="M342 164C342 111 309 75 258 65c-32-6-49-3-80-12-27-7-45 8-67 13-27 6-47 4-64 18-21 17-29 41-24 67 5 23 25 33 53 33 29 1 42 24 67 42 25 19 59 29 107 27 55-2 90-35 92-89Z"/>
</defs>
<rect class="diagram-card" x="3" y="3" width="362" height="277" rx="17" fill="url(#density-card-fill)" filter="url(#density-card-shadow)"/>
<text class="diagram-heading" x="20" y="38">疏密判坡</text>
<g class="density-contours">
<use class="density-contour" style="--i:0" href="#density-contour-shape"/>
<use class="density-contour" style="--i:1" href="#density-contour-shape" transform="translate(273 164) scale(.84) translate(-273 -164)"/>
<use class="density-contour" style="--i:2" href="#density-contour-shape" transform="translate(273 164) scale(.70) translate(-273 -164)"/>
<use class="density-contour" style="--i:3" href="#density-contour-shape" transform="translate(273 164) scale(.58) translate(-273 -164)"/>
<use class="density-contour" style="--i:4" href="#density-contour-shape" transform="translate(273 164) scale(.47) translate(-273 -164)"/>
<use class="density-contour" style="--i:5" href="#density-contour-shape" transform="translate(273 164) scale(.37) translate(-273 -164)"/>
<use class="density-contour" style="--i:6" href="#density-contour-shape" transform="translate(273 164) scale(.29) translate(-273 -164)"/>
<use class="density-contour" style="--i:7" href="#density-contour-shape" transform="translate(273 164) scale(.22) translate(-273 -164)"/>
<use class="density-contour" style="--i:8" href="#density-contour-shape" transform="translate(273 164) scale(.15) translate(-273 -164)"/>
</g>
<g class="density-callout density-callout--gentle">
<rect x="14" y="211" width="116" height="37" rx="8"/>
<path d="M60 190 52 207"/>
<circle cx="60" cy="190" r="7"/>
<text x="22" y="236">线疏 · 坡缓</text>
</g>
<g class="density-callout density-callout--steep">
<rect x="257" y="50" width="100" height="37" rx="8"/>
<path d="M293 125 307 88"/>
<circle cx="293" cy="125" r="7"/>
<text x="266" y="75">线密 · 坡陡</text>
</g>
</svg>
<div class="terrain-annotation" id="terrain-annotation" hidden>
<canvas id="terrain-annotation-canvas" aria-hidden="true"></canvas>
<svg class="terrain-callout-connector" id="terrain-callout-connector" aria-hidden="true" preserveAspectRatio="none">
<polygon id="terrain-callout-connector-shape"></polygon>
</svg>
<div class="terrain-callout" id="terrain-callout" role="status" aria-live="polite">
<span class="terrain-callout-kicker">动态判读</span>
<strong id="terrain-callout-title"></strong>
<p id="terrain-callout-copy"></p>
</div>
</div>
<div class="media-loading" id="media-loading" role="status">
<span class="loading-ring"></span>
<span>实验影像加载中</span>
</div>
<div class="media-label" id="media-label" aria-live="polite">
<span class="media-label-kicker" id="media-label-kicker">实验流程</span>
<strong id="media-label-title">形成交线与垂直投影</strong>
<small id="media-label-copy">点击“开始实验”,直接在当前画面播放形成交线视频</small>
</div>
<div class="video-progress" aria-hidden="true"><span id="video-progress-fill"></span></div>
</section>
<header class="topbar">
<div class="heading-group">
<span class="subject-chip">高中地理</span>
<div class="heading-copy">
<h1>等高线地形——五大典型地貌判读</h1>
<p>观察水平切割、垂直投影与等高线地貌特征</p>
</div>
</div>
<div class="top-actions">
<button class="glass-button" id="workflow-open" type="button">
<svg viewBox="0 0 24 24" aria-hidden="true"><path d="M4 5.5A3.5 3.5 0 0 1 7.5 2H11v17H7.5A3.5 3.5 0 0 0 4 22V5.5Zm16 0A3.5 3.5 0 0 0 16.5 2H13v17h3.5a3.5 3.5 0 0 1 3.5 3V5.5Z"/></svg>
<span>实验流程</span>
</button>
<button class="glass-button" id="fullscreen-button" type="button">
<svg viewBox="0 0 24 24" aria-hidden="true"><path d="M8 3H3v5M16 3h5v5M21 16v5h-5M8 21H3v-5"/></svg>
<span id="fullscreen-label">全屏</span>
</button>
</div>
</header>
<aside class="control-panel" aria-labelledby="panel-title">
<div class="panel-scroll">
<section class="flow-section">
<div class="section-heading">
<h2 id="panel-title">实验流程 · <span id="flow-count">1/4</span></h2>
<button class="panel-close" id="panel-close" type="button" aria-label="收起观察面板">×</button>
</div>
<div class="flow-track" id="flow-track">
<span class="flow-line" aria-hidden="true"><i id="flow-line-fill"></i></span>
<button class="flow-step is-active" type="button" data-step="0" aria-label="查看步骤一:等高切割">
<span class="step-dot">1</span><span class="step-name">等高切割</span>
</button>
<button class="flow-step" type="button" data-step="1" aria-label="查看步骤二:形成交线">
<span class="step-dot">2</span><span class="step-name">形成交线</span>
</button>
<button class="flow-step" type="button" data-step="2" aria-label="查看步骤三:投影成图">
<span class="step-dot">3</span><span class="step-name">投影成图</span>
</button>
<button class="flow-step" type="button" data-step="3" aria-label="查看步骤四:疏密判坡">
<span class="step-dot">4</span><span class="step-name">疏密判坡</span>
</button>
</div>
</section>
<section class="glass-card task-card" aria-labelledby="task-title">
<span class="card-eyebrow">当前步骤</span>
<h3 id="task-title">等高切割</h3>
<p id="task-description">观察水平面与山体在同一海拔相交,形成连续闭合线。</p>
<div class="fixed-condition" aria-label="实验固定条件">
<span><i></i>水平切面</span>
<strong>等高距 d = 10 m</strong>
</div>
</section>
<section class="glass-card terrain-card" aria-labelledby="terrain-title">
<div class="card-title-row">
<span class="card-eyebrow" id="terrain-title">典型地貌</span>
<button class="text-action" id="return-experiment" type="button" hidden>返回实验</button>
</div>
<div class="terrain-tabs" id="terrain-tabs" role="list" aria-label="五大典型地貌">
<button class="terrain-tab" type="button" data-landform="peak" aria-pressed="false">
<svg viewBox="0 0 42 34" aria-hidden="true"><path d="M4 29 16 9l5 8 5-12 12 24H4Z"/><path d="m20 19 4 6h-8l4-6Z" class="solid"/></svg>
<span>山峰</span>
</button>
<button class="terrain-tab" type="button" data-landform="ridge" aria-pressed="false">
<svg viewBox="0 0 42 34" aria-hidden="true"><path d="M3 29 12 9l7 5 7-10 13 25"/><path d="M10 28c5-7 9-10 14-11"/></svg>
<span>山脊</span>
</button>
<button class="terrain-tab" type="button" data-landform="valley" aria-pressed="false">
<svg viewBox="0 0 42 34" aria-hidden="true"><path d="M4 6c8 4 12 12 17 24C26 18 30 10 38 6"/><path d="M21 11v19" class="accent"/></svg>
<span>山谷</span>
</button>
<button class="terrain-tab" type="button" data-landform="saddle" aria-pressed="false">
<svg viewBox="0 0 42 34" aria-hidden="true"><path d="M4 25V8h10l7 8 7-8h10v17"/><path d="M14 9c0 6 2 9 7 9s7-3 7-9"/></svg>
<span>鞍部</span>
</button>
<button class="terrain-tab" type="button" data-landform="cliff" aria-pressed="false">
<svg viewBox="0 0 42 34" aria-hidden="true"><path d="M7 29V5h17l10 8v16"/><path d="M11 11h18M11 16h21M11 21h22"/></svg>
<span>陡崖</span>
</button>
</div>
</section>
<section class="glass-card observation-card" aria-labelledby="observation-heading">
<div class="observation-copy">
<span class="card-eyebrow">当前观察</span>
<h3 id="observation-heading">实验演示</h3>
<p id="observation-summary">点击开始实验,在当前背景中观察等高切割、交线形成与垂直投影。</p>
<ul class="feature-list" id="feature-list">
<li>同一条等高线上海拔相等</li>
<li>相邻等高线高差保持一致</li>
</ul>
</div>
<button class="top-view-card" id="top-view-toggle" type="button" disabled aria-pressed="false">
<span id="top-view-toggle-label">俯视图</span>
<small id="top-view-toggle-hint">选择地貌后切换</small>
<img id="top-view-thumbnail" alt="" decoding="async" hidden>
</button>
</section>
</div>
</aside>
<button class="panel-open" id="panel-open" type="button" aria-label="展开观察面板" hidden>
<span></span><span></span><span></span>
</button>
<div class="experiment-actions">
<button class="primary-button" id="play-button" type="button">
<span class="round-icon" id="play-icon" aria-hidden="true">
<svg viewBox="0 0 24 24"><path d="m9 6 9 6-9 6V6Z"/></svg>
</span>
<span id="play-label">开始实验</span>
</button>
<button class="glass-button reset-button" id="reset-button" type="button">
<svg viewBox="0 0 24 24" aria-hidden="true"><path d="M4 4v6h6M5.4 15.5A8 8 0 1 0 6 7"/></svg>
<span>重置</span>
</button>
</div>
<div class="hint-bar" id="hint-bar">
<svg viewBox="0 0 24 24" aria-hidden="true"><circle cx="12" cy="12" r="9"/><path d="M12 10v6M12 7h.01"/></svg>
<span id="hint-text">点击“开始实验”,观看形成交线视频</span>
</div>
<div class="toast" id="toast" role="status" aria-live="polite"></div>
</main>
<script src="assets/three.min.js"></script>
<script src="assets/terrain-annotation.js"></script>
<script src="assets/app.js"></script>
</body>
</html>
-549
View File
@@ -1,549 +0,0 @@
import 'dart:convert';
import 'dart:io';
import 'package:http/http.dart' as http;
/// 后端返回的错误(HTTP 非 2xx,或后端明确返回 ok=false)。
class ApiException implements Exception {
ApiException(this.message, {this.statusCode});
final String message;
final int? statusCode;
@override
String toString() => message;
}
/// 已安装模型。
class ModelInfo {
ModelInfo.fromJson(Map<String, dynamic> json)
: id = json['id'] as String? ?? '',
name = json['name'] as String? ?? '',
description = json['description'] as String? ?? '',
version = json['version'] as String? ?? '',
author = json['author'] as String? ?? '',
sizeBytes = (json['sizeBytes'] as num?)?.toInt() ?? 0,
sizeText = json['sizeText'] as String? ?? '',
tags = _stringList(json['tags']),
hasPreview = json['hasPreview'] as bool? ?? false,
previewUrl = json['previewUrl'] as String? ?? '',
directory = json['directory'] as String? ?? '',
dataDirectory = json['dataDirectory'] as String? ?? '';
final String id;
final String name;
final String description;
final String version;
final String author;
final int sizeBytes;
final String sizeText;
final List<String> tags;
final bool hasPreview;
final String previewUrl;
final String directory;
final String dataDirectory;
String get metaText => 'v$version · $sizeText';
}
/// 模型源。
class SourceInfo {
SourceInfo.fromJson(Map<String, dynamic> json)
: id = json['id'] as String? ?? '',
name = json['name'] as String? ?? '',
url = json['url'] as String? ?? '',
enabled = json['enabled'] as bool? ?? false,
builtIn = json['builtIn'] as bool? ?? false,
host = json['host'] as String? ?? '';
final String id;
final String name;
final String url;
final bool enabled;
final bool builtIn;
final String host;
}
/// 远端可下载模型。
class RemoteModelInfo {
RemoteModelInfo.fromJson(Map<String, dynamic> json)
: id = json['id'] as String? ?? '',
name = json['name'] as String? ?? '',
description = json['description'] as String? ?? '',
version = json['version'] as String? ?? '',
sizeBytes = (json['sizeBytes'] as num?)?.toInt() ?? 0,
sizeText = json['sizeText'] as String? ?? '',
sourceId = json['sourceId'] as String? ?? '',
installed = json['installed'] as bool? ?? false,
installedVersion = json['installedVersion'] as String?;
final String id;
final String name;
final String description;
final String version;
final int sizeBytes;
final String sizeText;
final String sourceId;
final bool installed;
final String? installedVersion;
}
/// 一次远端源索引结果。
class SourceIndexInfo {
SourceIndexInfo.fromJson(Map<String, dynamic> json)
: sourceId = json['sourceId'] as String? ?? '',
root = json['root'] as String? ?? '',
fromCache = json['fromCache'] as bool? ?? false,
error = json['error'] as String?,
resolvedFrom = json['resolvedFrom'] as String? ?? '',
models = (json['models'] as List<dynamic>? ?? const [])
.map((e) => RemoteModelInfo.fromJson(e as Map<String, dynamic>))
.toList();
final String sourceId;
final String root;
final bool fromCache;
final String? error;
final String resolvedFrom;
final List<RemoteModelInfo> models;
}
/// 下载任务。
class JobInfo {
JobInfo.fromJson(Map<String, dynamic> json)
: id = json['id'] as String? ?? '',
modelId = json['modelId'] as String? ?? '',
name = json['name'] as String? ?? '',
version = json['version'] as String? ?? '',
state = json['state'] as String? ?? 'Queued',
progress = (json['progress'] as num?)?.toDouble() ?? 0,
statusText = json['statusText'] as String? ?? '',
detailText = json['detailText'] as String? ?? '',
error = json['error'] as String?,
isActive = json['isActive'] as bool? ?? false,
canRetry = json['canRetry'] as bool? ?? false,
isDone = json['isDone'] as bool? ?? false;
final String id;
final String modelId;
final String name;
final String version;
final String state;
final double progress;
final String statusText;
final String detailText;
final String? error;
final bool isActive;
final bool canRetry;
final bool isDone;
}
/// 界面语言选项。
class LanguageInfo {
LanguageInfo.fromJson(Map<String, dynamic> json)
: code = json['code'] as String? ?? '',
label = json['label'] as String? ?? '';
final String code;
final String label;
}
/// 设置。
class SettingsInfo {
SettingsInfo.fromJson(Map<String, dynamic> json)
: language = json['language'] as String? ?? 'auto',
theme = json['theme'] as String? ?? 'light',
accentColor = json['accentColor'] as String? ?? '#8FB6FF',
renderFps = (json['renderFps'] as num?)?.toInt() ?? 120,
memoryMb = (json['memoryMb'] as num?)?.toInt() ?? 2048,
memoryAuto = json['memoryAuto'] as bool? ?? true,
autoUpdateOnStartup = json['autoUpdateOnStartup'] as bool? ?? true,
requireSignedManifest = json['requireSignedManifest'] as bool? ?? true,
updateRepository = json['updateRepository'] as String? ?? '',
updateLocalRoot = json['updateLocalRoot'] as String?,
modelRootOverride = json['modelRootOverride'] as String?,
memoryBudgetMb = (json['memoryBudgetMb'] as num?)?.toInt() ?? 0,
memoryUsageText = json['memoryUsageText'] as String? ?? '',
modelRoot = json['modelRoot'] as String? ?? '',
dataRoot = json['dataRoot'] as String? ?? '',
settingsFile = json['settingsFile'] as String? ?? '',
version = json['version'] as String? ?? '',
platform = json['platform'] as String? ?? '',
sources = (json['sources'] as List<dynamic>? ?? const [])
.map((e) => SourceInfo.fromJson(e as Map<String, dynamic>))
.toList(),
languages = (json['languages'] as List<dynamic>? ?? const [])
.map((e) => LanguageInfo.fromJson(e as Map<String, dynamic>))
.toList();
final String language;
final String theme;
final String accentColor;
final int renderFps;
final int memoryMb;
final bool memoryAuto;
final bool autoUpdateOnStartup;
final bool requireSignedManifest;
final String updateRepository;
final String? updateLocalRoot;
final String? modelRootOverride;
final int memoryBudgetMb;
final String memoryUsageText;
final String modelRoot;
final String dataRoot;
final String settingsFile;
final String version;
final String platform;
final List<SourceInfo> sources;
final List<LanguageInfo> languages;
}
/// 设置补丁:只提交要改的字段。
class SettingsPatch {
const SettingsPatch({
this.language,
this.theme,
this.accentColor,
this.renderFps,
this.memoryMb,
this.memoryAuto,
this.autoUpdateOnStartup,
this.requireSignedManifest,
this.updateRepository,
this.updateLocalRoot,
this.modelRootOverride,
});
final String? language;
final String? theme;
final String? accentColor;
final int? renderFps;
final int? memoryMb;
final bool? memoryAuto;
final bool? autoUpdateOnStartup;
final bool? requireSignedManifest;
final String? updateRepository;
final String? updateLocalRoot;
final String? modelRootOverride;
Map<String, dynamic> toJson() {
final map = <String, dynamic>{};
if (language != null) map['language'] = language;
if (theme != null) map['theme'] = theme;
if (accentColor != null) map['accentColor'] = accentColor;
if (renderFps != null) map['renderFps'] = renderFps;
if (memoryMb != null) map['memoryMb'] = memoryMb;
if (memoryAuto != null) map['memoryAuto'] = memoryAuto;
if (autoUpdateOnStartup != null) map['autoUpdateOnStartup'] = autoUpdateOnStartup;
if (requireSignedManifest != null) map['requireSignedManifest'] = requireSignedManifest;
if (updateRepository != null) map['updateRepository'] = updateRepository;
if (updateLocalRoot != null) map['updateLocalRoot'] = updateLocalRoot;
if (modelRootOverride != null) map['modelRootOverride'] = modelRootOverride;
return map;
}
}
/// 健康检查。
class HealthInfo {
HealthInfo.fromJson(Map<String, dynamic> json)
: ok = json['ok'] as bool? ?? false,
version = json['version'] as String? ?? '',
platform = json['platform'] as String? ?? '',
uiAvailable = json['uiAvailable'] as bool? ?? false,
uiError = json['uiError'] as String?,
sessionProof = json['sessionProof'] as String?;
final bool ok;
final String version;
final String platform;
final bool uiAvailable;
final String? uiError;
/// 后端会话令牌的指纹;前端可用于诊断「是否连到了正确的后端」。
final String? sessionProof;
}
/// 一次更新检查的结果。
class UpdateCheckInfo {
UpdateCheckInfo.fromJson(Map<String, dynamic> json)
: outcome = json['outcome'] as String? ?? '',
message = json['message'] as String? ?? '',
updatedModels = (json['updatedModels'] as num?)?.toInt() ?? 0,
modelNames = _stringList(json['modelNames']),
launcherMessage = json['launcherMessage'] as String?,
error = json['error'] as String?,
launcherLatest = json['launcherLatest'] as String?,
sourceName = json['sourceName'] as String? ?? '';
final String outcome;
final String message;
final int updatedModels;
final List<String> modelNames;
final String? launcherMessage;
final String? error;
final String? launcherLatest;
final String sourceName;
}
/// 贡献者。
class ContributorInfo {
ContributorInfo.fromJson(Map<String, dynamic> json)
: name = json['name'] as String? ?? '',
contributions = (json['contributions'] as num?)?.toInt() ?? 0,
avatarUrl = json['avatarUrl'] as String?;
final String name;
final int contributions;
final String? avatarUrl;
}
/// 关于页数据。
class AboutInfo {
AboutInfo.fromJson(Map<String, dynamic> json)
: appName = json['appName'] as String? ?? '',
version = json['version'] as String? ?? '',
platform = json['platform'] as String? ?? '',
repository = json['repository'] as String? ?? '',
sourceLanguage = json['sourceLanguage'] as String? ?? 'C#',
frontend = json['frontend'] as String? ?? 'Flutter',
contributors = (json['contributors'] as List<dynamic>? ?? const [])
.map((e) => ContributorInfo.fromJson(e as Map<String, dynamic>))
.toList();
final String appName;
final String version;
final String platform;
final String repository;
/// 源码语言(后端 / 模型层),由后端 `/api/about` 返回。
final String sourceLanguage;
/// 前端框架,由后端 `/api/about` 返回。
final String frontend;
final List<ContributorInfo> contributors;
}
/// 通用操作结果。
class ActionResult {
ActionResult.fromJson(Map<String, dynamic> json)
: ok = json['ok'] as bool? ?? false,
message = json['message'] as String? ?? '';
final bool ok;
final String message;
}
List<String> _stringList(dynamic value) =>
(value as List<dynamic>? ?? const []).map((e) => e.toString()).toList();
/// GC-UI 后端客户端。
///
/// 后端是本地伴随进程,端口由启动器(GC-BOOT)选定后通过 `GC_UI_PORT`
/// 环境变量传进来 —— 这样端口被占用时换端口不用重新编译前端。
/// 也可用 `--dart-define=GC_UI_BASE_URL=http://127.0.0.1:12345` 强制指定。
class GcApi {
GcApi({String? baseUrl})
: baseUrl = baseUrl ?? defaultBaseUrl;
/// 复用同一个 HTTP 连接:轮询(下载任务每秒一次)时每次都新建连接
/// 会不断握手,桌面端也能明显看到延迟抖动。
static final http.Client _client = http.Client();
/// 兜底默认端口,与后端 GC.Services.GcUiContract.DefaultPort 保持一致。
static const int fallbackPort = 17890;
static String get defaultBaseUrl {
const fromDefine = String.fromEnvironment('GC_UI_BASE_URL');
if (fromDefine.isNotEmpty) return fromDefine;
final fromEnvUrl = Platform.environment['GC_UI_BASE_URL'];
if (fromEnvUrl != null && fromEnvUrl.isNotEmpty) return fromEnvUrl;
// 启动器通过 GC_UI_PORT 传端口(主路径)。
final port = int.tryParse(Platform.environment['GC_UI_PORT'] ?? '');
if (port != null) return 'http://127.0.0.1:$port';
// 手动起后端 / 前端调试时没有环境变量:读后端写的 .GC/ui-backend.json。
final discovered = _endpointFileUrl();
if (discovered != null) return discovered;
return 'http://127.0.0.1:$fallbackPort';
}
/// 从运行目录下的 `.GC/ui-backend.json` 发现后端地址。
///
/// 后端每次启动都会写这个文件(port / pid / url)。只认 24 小时内的记录:
/// 更早的多半是上次遗留的,连过去只会得到一个「无法连接」。
static String? _endpointFileUrl() {
try {
final file = File('${Directory.current.path}/.GC/ui-backend.json');
if (!file.existsSync()) return null;
final age = DateTime.now().difference(file.lastModifiedSync());
if (age.inHours >= 24) return null;
final decoded = jsonDecode(file.readAsStringSync());
if (decoded is! Map<String, dynamic>) return null;
final url = decoded['url'];
if (url is String && url.startsWith('http://127.0.0.1:')) return url;
final port = (decoded['port'] as num?)?.toInt();
if (port != null && port > 0 && port < 65536) {
return 'http://127.0.0.1:$port';
}
} catch (_) {
// 文件损坏 / 无权限:退回默认端口即可
}
return null;
}
final String baseUrl;
/// 启动器注入的一次性会话令牌。后端在发布包模式下会校验它,
/// 防止前端误连到同机其他进程伪造的「后端」。
static final String? _sessionToken = _readSessionToken();
static String? _readSessionToken() {
const fromDefine = String.fromEnvironment('GC_UI_TOKEN');
if (fromDefine.isNotEmpty) return fromDefine;
final fromEnv = Platform.environment['GC_UI_TOKEN'];
return (fromEnv != null && fromEnv.isNotEmpty) ? fromEnv : null;
}
/// 带会话令牌的请求头;没有令牌时返回 const 空 map(调试/独立后端模式)。
Map<String, String> get _authHeaders =>
_sessionToken == null ? const {} : {'X-GC-UI-Token': _sessionToken!};
Uri _uri(String path, [Map<String, String>? query]) =>
Uri.parse('$baseUrl$path').replace(queryParameters: query);
Future<dynamic> _send(String method, String path,
{Map<String, String>? query, Object? body}) async {
final uri = _uri(path, query);
final auth = _authHeaders;
late http.Response response;
try {
switch (method) {
case 'GET':
response = await _client.get(uri, headers: auth)
.timeout(const Duration(seconds: 30));
break;
case 'POST':
response = await _client
.post(uri,
headers: <String, String>{...auth, 'Content-Type': 'application/json'},
body: body == null ? null : jsonEncode(body))
.timeout(const Duration(seconds: 120));
break;
case 'DELETE':
response = await _client.delete(uri, headers: auth)
.timeout(const Duration(seconds: 30));
break;
default:
throw ApiException('不支持的方法 $method');
}
} on ApiException {
rethrow;
} catch (error) {
throw ApiException('无法连接后端($baseUrl):$error');
}
final text = utf8.decode(response.bodyBytes);
dynamic decoded;
if (text.isNotEmpty) {
try {
decoded = jsonDecode(text);
} catch (_) {
decoded = null;
}
}
if (response.statusCode >= 400) {
final message = decoded is Map<String, dynamic>
? (decoded['message'] as String? ?? 'HTTP ${response.statusCode}')
: 'HTTP ${response.statusCode}';
throw ApiException(message, statusCode: response.statusCode);
}
return decoded;
}
List<Map<String, dynamic>> _asList(dynamic value) =>
(value as List<dynamic>? ?? const [])
.map((e) => e as Map<String, dynamic>)
.toList();
Future<HealthInfo> health() async =>
HealthInfo.fromJson(await _send('GET', '/api/health') as Map<String, dynamic>);
Future<List<ModelInfo>> models() async =>
_asList(await _send('GET', '/api/models')).map(ModelInfo.fromJson).toList();
Future<ActionResult> launchModel(String id) async => ActionResult.fromJson(
await _send('POST', '/api/models/$id/launch') as Map<String, dynamic>);
Future<ActionResult> deleteModel(String id) async => ActionResult.fromJson(
await _send('DELETE', '/api/models/$id') as Map<String, dynamic>);
Future<SettingsInfo> settings() async =>
SettingsInfo.fromJson(await _send('GET', '/api/settings') as Map<String, dynamic>);
Future<SettingsInfo> saveSettings(SettingsPatch patch) async =>
SettingsInfo.fromJson(await _send('POST', '/api/settings', body: patch.toJson())
as Map<String, dynamic>);
Future<List<SourceInfo>> sources() async =>
_asList(await _send('GET', '/api/sources')).map(SourceInfo.fromJson).toList();
Future<SourceIndexInfo> remoteModels({String? sourceId, bool force = false}) async =>
SourceIndexInfo.fromJson(await _send('GET', '/api/remote/models', query: {
if (sourceId != null) 'sourceId': sourceId,
'force': force.toString(),
}) as Map<String, dynamic>);
Future<List<JobInfo>> jobs() async =>
_asList(await _send('GET', '/api/download/jobs')).map(JobInfo.fromJson).toList();
Future<JobInfo> startDownload(String sourceId, String modelId) async =>
JobInfo.fromJson(await _send('POST', '/api/download',
body: {'sourceId': sourceId, 'modelId': modelId}) as Map<String, dynamic>);
Future<JobInfo> cancelJob(String id) async => JobInfo.fromJson(
await _send('POST', '/api/download/$id/cancel') as Map<String, dynamic>);
Future<JobInfo> retryJob(String id) async => JobInfo.fromJson(
await _send('POST', '/api/download/$id/retry') as Map<String, dynamic>);
Future<JobInfo> removeJob(String id) async => JobInfo.fromJson(
await _send('POST', '/api/download/$id/remove') as Map<String, dynamic>);
Future<ActionResult> clearFinished() async => ActionResult.fromJson(
await _send('POST', '/api/download/clear-finished') as Map<String, dynamic>);
Future<UpdateCheckInfo> checkUpdate({bool force = true}) async =>
UpdateCheckInfo.fromJson(
await _send('POST', '/api/update/check', body: {'force': force})
as Map<String, dynamic>);
Future<AboutInfo> about() async =>
AboutInfo.fromJson(await _send('GET', '/api/about') as Map<String, dynamic>);
Future<ActionResult> openFolder(String path) async => ActionResult.fromJson(
await _send('POST', '/api/shell/open-folder', body: {'path': path})
as Map<String, dynamic>);
Future<ActionResult> openUrl(String url) async => ActionResult.fromJson(
await _send('POST', '/api/shell/open-url', body: {'url': url})
as Map<String, dynamic>);
/// 模型封面图地址(直接给 Image.network 用,带不上自定义头,令牌走 query 参数)。
String previewUrl(ModelInfo model) {
if (_sessionToken == null) return '$baseUrl${model.previewUrl}';
final uri = Uri.parse('$baseUrl${model.previewUrl}');
return uri.replace(queryParameters: {
...uri.queryParameters,
'X-GC-UI-Token': _sessionToken!,
}).toString();
}
}
-187
View File
@@ -1,187 +0,0 @@
import 'dart:async';
import 'package:flutter/foundation.dart';
import 'api_client.dart';
import 'i18n.dart';
import 'theme.dart';
/// 外壳状态:后端客户端 + 设置 + 健康状态 + 更新状态条。
///
/// 各页面只读这里的数据、通过这里的方法改后端,避免每页各持一份状态。
class ShellController extends ChangeNotifier {
ShellController({GcApi? api}) : api = api ?? GcApi();
final GcApi api;
int index = 0;
SettingsInfo? settings;
HealthInfo? health;
String? loadError;
bool updateBarVisible = false;
bool updateBusy = false;
double updateProgress = 0;
String updateStatus = '';
String updateDetail = '';
String launcherNotice = '';
/// 模型库版本号:安装 / 删除 / 下载完成后自增,首页据此重新拉列表。
///
/// 首页被 `Offstage` 保活,切走再切回不会重建;没有这个信号时,
/// 下载完模型回到首页仍然显示旧的空列表。
int modelsRevision = 0;
Timer? _retryTimer;
int _retryAttempt = 0;
bool get backendReady => settings != null;
Future<void> bootstrap() async {
_retryTimer?.cancel();
HealthInfo? healthResult;
SettingsInfo? settingsResult;
Object? firstError;
// 两个请求互不依赖,并行发;各自捕获异常,避免一方失败时
// 另一个的 Future 抛成未处理异常(Flutter 会在控制台打出恶性警告)。
await Future.wait<void>(<Future<void>>[
() async {
try {
healthResult = await api.health();
} catch (error) {
firstError ??= error;
}
}(),
() async {
try {
settingsResult = await api.settings();
} catch (error) {
firstError ??= error;
}
}(),
]);
if (healthResult != null) health = healthResult;
if (settingsResult != null) {
settings = settingsResult;
_applySettings(settingsResult!);
}
if (firstError != null && settingsResult == null) {
loadError = firstError.toString();
_scheduleRetry();
} else {
loadError = null;
_retryAttempt = 0;
}
notifyListeners();
}
/// 后端没起来时自动重试(2s、4s、8s…最多 5 次),不必让用户手动点。
void _scheduleRetry() {
if (_retryAttempt >= 5) return;
final seconds = 1 << _retryAttempt; // 1,2,4,8,16
_retryAttempt++;
_retryTimer?.cancel();
_retryTimer = Timer(Duration(seconds: seconds), () {
if (settings == null) bootstrap();
});
}
void _applySettings(SettingsInfo value) {
I18n.setLanguage(value.language);
GcPalette.apply(value.accentColor);
GcPalette.applyTheme(value.theme);
}
void goTo(int value) {
if (index == value) return;
index = value;
notifyListeners();
}
/// 模型库有变化(安装 / 删除 / 下载完成):通知首页刷新。
void modelsChanged() {
modelsRevision++;
notifyListeners();
}
Future<void> reloadSettings() async {
try {
settings = await api.settings();
loadError = null;
_applySettings(settings!);
} catch (error) {
loadError = error.toString();
}
notifyListeners();
}
Future<void> saveSettings(SettingsPatch patch) async {
try {
settings = await api.saveSettings(patch);
loadError = null;
_applySettings(settings!);
} catch (error) {
loadError = error.toString();
}
notifyListeners();
}
void setUpdateStatus({
bool? visible,
bool? busy,
double? progress,
String? status,
String? detail,
String? notice,
}) {
if (visible != null) updateBarVisible = visible;
if (busy != null) updateBusy = busy;
if (progress != null) updateProgress = progress;
if (status != null) updateStatus = status;
if (detail != null) updateDetail = detail;
if (notice != null) launcherNotice = notice;
notifyListeners();
}
/// 检查模型 / 启动器更新(设置页与状态条共用)。
Future<void> checkUpdate({bool force = true}) async {
if (updateBusy) return;
setUpdateStatus(
visible: true,
busy: true,
progress: 0,
status: T('update.checking'),
detail: '',
notice: '',
);
try {
final result = await api.checkUpdate(force: force);
setUpdateStatus(
busy: false,
progress: 1,
status: result.message.isEmpty ? T('update.done') : result.message,
detail: result.error ?? '',
notice: result.launcherMessage ?? '',
);
if (result.updatedModels > 0) modelsChanged();
} catch (error) {
setUpdateStatus(
busy: false,
status: T('update.offline'),
detail: error.toString(),
);
}
}
@override
void dispose() {
_retryTimer?.cancel();
super.dispose();
}
}
-312
View File
@@ -1,312 +0,0 @@
import 'package:flutter/widgets.dart';
/// 轻量 i18n:键值表 + 运行时切换,和后端 `GC/src/Assets/i18n/*.json` 的键保持一致。
class I18n {
I18n._();
static const List<String> supported = <String>['zh-CN', 'en'];
static final ValueNotifier<String> language = ValueNotifier<String>('zh-CN');
static const Map<String, Map<String, String>> _tables = <String, Map<String, String>>{
'zh-CN': <String, String>{
'app.name': 'Morris GC',
'app.tagline': '天文教学模型 · 可视化启动器',
'nav.home': '主页',
'nav.courseware': '等高线课件',
'nav.download': '下载',
'nav.settings': '设置',
'nav.about': '关于',
'home.title': '模型库',
'home.subtitle': '选择模型,用可交互的三维演示讲清自转、公转与四季成因。',
'home.launch': '启动模型',
'home.download': '下载模型',
'home.settings': '设置',
'home.installed': '已安装模型',
'home.count': '{0} 个模型',
'home.noDescription': '暂无简介',
'home.empty': '模型库还是空的',
'home.emptyHint': '启动时会自动检查并下载模型。若当前断网:可把模型文件夹放进 .GC/model/ 后重新打开,或联网后在「下载」页点重试。',
'home.emptyAction': '去下载模型',
'home.open': '打开目录',
'home.delete': '删除',
'home.deleteConfirm': '删除模型「{0}」?模型文件会从本地模型库移除。',
'home.stats.models': '已安装',
'home.stats.sources': '模型源',
'home.stats.memory': '内存预算',
'home.recent': '选择模型后点击「启动模型」',
'home.launchHint': '模型在自己的窗口里运行,可播放/暂停、切换视角并使用教学要点。',
'dl.title': '下载模型',
'dl.subtitle': '从内置模型源读取可下载模型;模型源在「设置」里查看。',
'dl.sources': '模型源',
'dl.refresh': '刷新',
'dl.available': '可用模型',
'dl.download': '下载',
'dl.installed': '已安装',
'dl.reinstall': '重新下载',
'dl.background': '后台任务',
'dl.bgEmpty': '暂无后台任务',
'dl.cancel': '取消',
'dl.retry': '重试',
'dl.clearDone': '清除已完成',
'dl.removeTask': '移除',
'dl.status.queued': '排队中',
'dl.status.downloading': '下载中',
'dl.status.done': '已完成',
'dl.status.failed': '失败',
'dl.status.canceled': '已取消',
'dl.empty': '这个源里没有模型',
'dl.emptyHint': '仓库需要包含 model/<模型ID>/<模型ID>.json 结构',
'dl.syncing': '正在读取模型源…',
'dl.ready': '共 {0} 个模型',
'dl.fromCache': '本地缓存',
'dl.pickSource': '选择一个模型源,查看可下载的模型',
'set.title': '设置',
'set.subtitle': '模型源、启动时内存分配与本地存储。',
'set.general': '通用',
'set.appearance': '外观',
'set.theme': '主题模式',
'set.theme.desc': '深色、浅色,或跟随系统设置。',
'set.theme.dark': '深色',
'set.theme.light': '浅色',
'set.theme.system': '跟随系统',
'set.accent': '主题颜色',
'set.accent.desc': '选择启动器的主色调,按钮、滑块与高亮会同步换色。',
'set.accent.custom': '自定义颜色',
'set.accent.hexHint': '格式 #RRGGBB,例如 #8FB6FF',
'set.accent.invalid': '颜色格式无效,请使用 #RRGGBB',
'set.language': '界面语言',
'set.language.auto': '跟随系统',
'set.fps': '渲染帧率',
'set.fps.desc': '越高越顺滑,CPU 占用也越高。',
'set.memory': '启动时运行内存分配',
'set.memory.desc': '启动器把这份预算交给模型:模型自己决定用它缓存多少数据(贴图分辨率、缓冲等)。',
'set.memory.current': '当前占用',
'set.memory.auto': '自动(根据设备内存分配)',
'set.memory.hint': '建议 2048 MB 以上,低配设备可选 1024 MB。',
'set.sources': '模型源',
'set.sources.desc': '停用的模型源不会出现在下载页。',
'set.sourceEnabled': '启用',
'set.storage': '存储',
'set.modelDir': '模型库目录',
'set.dataDir': '数据目录',
'set.openFolder': '打开文件夹',
'set.clearCache': '清理缓存',
'set.cacheCleared': '缓存已清理',
'set.about': '关于',
'set.version': '版本',
'set.platform': '平台',
'set.license': '许可',
'set.licenseValue': 'MIT',
'set.checkUpdate': '检查更新',
'set.checkUpdate.desc': '启动时自动检查模型与启动器是否为最新版。',
'set.backend': '后端服务',
'set.backend.desc': '界面(Flutter)与后端(.NET)分离,后端只监听本机回环地址。',
'set.backend.ui': '模型窗口宿主',
'set.backend.uiOk': '可用',
'set.backend.uiBad': '不可用',
'update.title': '自动更新',
'update.auto': '启动时自动检查更新',
'update.checkNow': '检查更新',
'update.source': '更新源',
'update.lastCheck': '上次检查',
'update.never': '尚未检查',
'update.none': '无',
'update.checking': '正在检查更新…',
'update.offline': '暂时无法连接更新服务器,继续使用本地模型',
'update.noChange': '模型与启动器均为最新版',
'update.applied': '已更新 {0} 个模型,立即生效',
'update.done': '更新检查完成',
'update.pendingReady': '启动器新版 {0} 已就绪,下次启动生效',
'common.cancel': '取消',
'common.confirm': '确定',
'common.delete': '删除',
'common.close': '关闭',
'common.open': '打开',
'common.applied': '已应用',
'common.confirmTitle': '请确认',
'common.retry': '重试',
'common.loading': '加载中…',
'common.error': '出错了',
'common.refresh': '刷新',
'about.developers': '开发者',
'about.contributorsHint': '来自仓库提交记录',
'about.repository': '仓库',
'about.openRepository': '打开仓库',
'about.contributions': '{0} 次提交',
'about.noContributors': '暂无贡献者信息',
'about.architecture': '架构',
'about.architectureValue': 'Flutter 前端 + .NET 后端(本地 HTTP)',
'about.sourceLanguage': '源码语言',
'about.frontend': '前端',
'about.gitService': 'Git 服务',
'about.thanks': '感谢',
'about.thanksHint': '特别感谢以下朋友的支持',
'about.thanksGit': 'Git 服务与部署支持',
'about.thanksGeo': '地理学科内容指导',
},
'en': <String, String>{
'app.name': 'Morris GC',
'app.tagline': 'Astronomy teaching models · visual launcher',
'nav.home': 'Home',
'nav.courseware': 'Contour Course',
'nav.download': 'Download',
'nav.settings': 'Settings',
'nav.about': 'About',
'home.title': 'Model library',
'home.subtitle': 'Pick a model and explain rotation, revolution and the seasons with an interactive 3D scene.',
'home.launch': 'Launch model',
'home.download': 'Get models',
'home.settings': 'Settings',
'home.installed': 'Installed models',
'home.count': '{0} models',
'home.noDescription': 'No description',
'home.empty': 'No models yet',
'home.emptyHint': 'Models are checked and downloaded on startup. Offline: drop model folders into .GC/model/ and reopen, or retry from the Download page once online.',
'home.emptyAction': 'Get models',
'home.open': 'Open folder',
'home.delete': 'Delete',
'home.deleteConfirm': 'Delete the model "{0}"? Its files will be removed from the local library.',
'home.stats.models': 'Installed',
'home.stats.sources': 'Sources',
'home.stats.memory': 'Memory budget',
'home.recent': 'Select a model, then press Launch',
'home.launchHint': 'Models open in their own window with play/pause, view controls and teaching notes.',
'dl.title': 'Download',
'dl.subtitle': 'Read downloadable models from the built-in sources; manage sources in Settings.',
'dl.sources': 'Sources',
'dl.refresh': 'Refresh',
'dl.available': 'Available models',
'dl.download': 'Download',
'dl.installed': 'Installed',
'dl.reinstall': 'Re-download',
'dl.background': 'Background tasks',
'dl.bgEmpty': 'No background tasks',
'dl.cancel': 'Cancel',
'dl.retry': 'Retry',
'dl.clearDone': 'Clear finished',
'dl.removeTask': 'Remove',
'dl.status.queued': 'Queued',
'dl.status.downloading': 'Downloading',
'dl.status.done': 'Completed',
'dl.status.failed': 'Failed',
'dl.status.canceled': 'Canceled',
'dl.empty': 'No models in this source',
'dl.emptyHint': 'A source needs model/<model-id>/<model-id>.json layout',
'dl.syncing': 'Reading model source…',
'dl.ready': '{0} models',
'dl.fromCache': 'cached',
'dl.pickSource': 'Select a source to see available models',
'set.title': 'Settings',
'set.subtitle': 'Model sources, startup memory allocation and local storage.',
'set.general': 'General',
'set.appearance': 'Appearance',
'set.theme': 'Theme mode',
'set.theme.desc': 'Dark, light, or follow the system setting.',
'set.theme.dark': 'Dark',
'set.theme.light': 'Light',
'set.theme.system': 'System',
'set.accent': 'Theme color',
'set.accent.desc': 'Pick the launcher accent color; buttons, sliders and highlights follow it.',
'set.accent.custom': 'Custom color',
'set.accent.hexHint': 'Format #RRGGBB, e.g. #8FB6FF',
'set.accent.invalid': 'Invalid color, use #RRGGBB',
'set.language': 'Language',
'set.language.auto': 'System',
'set.fps': 'Render frame rate',
'set.fps.desc': 'Higher is smoother but uses more CPU.',
'set.memory': 'Startup memory allocation',
'set.memory.desc': 'The launcher hands this budget to each model; models decide how much data to cache with it.',
'set.memory.current': 'In use',
'set.memory.auto': 'Auto (allocate based on device memory)',
'set.memory.hint': '2048 MB or more is recommended; 1024 MB for low-end devices.',
'set.sources': 'Model sources',
'set.sources.desc': 'Disabled sources are hidden from the Download page.',
'set.sourceEnabled': 'Enabled',
'set.storage': 'Storage',
'set.modelDir': 'Model library',
'set.dataDir': 'Data folder',
'set.openFolder': 'Open folder',
'set.clearCache': 'Clear cache',
'set.cacheCleared': 'Cache cleared',
'set.about': 'About',
'set.version': 'Version',
'set.platform': 'Platform',
'set.license': 'License',
'set.licenseValue': 'MIT',
'set.checkUpdate': 'Check for updates',
'set.checkUpdate.desc': 'Check on startup whether models and the launcher are up to date.',
'set.backend': 'Backend service',
'set.backend.desc': 'The UI (Flutter) and the backend (.NET) are separate; the backend only listens on loopback.',
'set.backend.ui': 'Model window host',
'set.backend.uiOk': 'available',
'set.backend.uiBad': 'unavailable',
'update.title': 'Auto update',
'update.auto': 'Check for updates on startup',
'update.checkNow': 'Check now',
'update.source': 'Update source',
'update.lastCheck': 'Last check',
'update.never': 'Never',
'update.none': 'None',
'update.checking': 'Checking for updates…',
'update.offline': 'Update server unavailable — continuing with local models',
'update.noChange': 'Models and launcher are up to date',
'update.applied': 'Updated {0} models, applied now',
'update.done': 'Update check complete',
'update.pendingReady': 'Launcher {0} is ready, applies on next start',
'common.cancel': 'Cancel',
'common.confirm': 'Confirm',
'common.delete': 'Delete',
'common.close': 'Close',
'common.open': 'Open',
'common.applied': 'Applied',
'common.confirmTitle': 'Please confirm',
'common.retry': 'Retry',
'common.loading': 'Loading…',
'common.error': 'Something went wrong',
'common.refresh': 'Refresh',
'about.developers': 'Developers',
'about.contributorsHint': 'From repository commits',
'about.repository': 'Repository',
'about.openRepository': 'Open repository',
'about.contributions': '{0} commits',
'about.noContributors': 'No contributor information',
'about.architecture': 'Architecture',
'about.architectureValue': 'Flutter frontend + .NET backend (local HTTP)',
'about.sourceLanguage': 'Source language',
'about.frontend': 'Frontend',
'about.gitService': 'Git hosting',
'about.thanks': 'Thanks',
'about.thanksHint': 'Special thanks to',
'about.thanksGit': 'Git hosting and deployment',
'about.thanksGeo': 'Geography content guidance',
},
};
/// 取一条文案;`{0}` 这类占位符用 [args] 填充。
static String t(String key, [List<Object?> args = const <Object?>[]]) {
final table = _tables[language.value] ?? _tables['zh-CN']!;
var text = table[key] ?? _tables['zh-CN']![key] ?? key;
for (var i = 0; i < args.length; i++) {
text = text.replaceAll('{$i}', '${args[i]}');
}
return text;
}
/// 把后端语言设置(auto / zh-CN / en)解析成实际语言。
static String resolve(String? preference) {
if (preference != null && preference.isNotEmpty && preference != 'auto') {
return preference.startsWith('en') ? 'en' : 'zh-CN';
}
final locale = WidgetsBinding.instance.platformDispatcher.locale;
return locale.languageCode == 'zh' ? 'zh-CN' : 'en';
}
static void setLanguage(String code) {
final resolved = resolve(code);
if (language.value != resolved) language.value = resolved;
}
}
/// 便捷取词:`T('nav.home')`。
String T(String key, [List<Object?> args = const <Object?>[]]) => I18n.t(key, args);
-69
View File
@@ -1,69 +0,0 @@
import 'package:flutter/material.dart';
import 'controller.dart';
import 'i18n.dart';
import 'shell.dart';
import 'theme.dart';
void main() {
// 桌面端无需异步初始化外部插件:尽早绑定并直接渲染首帧,
// 让窗口在引擎就绪后立刻出现,后端探测在外壳里异步进行。
WidgetsFlutterBinding.ensureInitialized();
runApp(const GcUiApp());
}
/// GC-UI 前端:Flutter 桌面应用(Windows / macOS / Linux)。
///
/// 界面全部在这里;模型扫描、下载、更新、设置、模型窗口宿主都在后端
/// (GC-UI/backend/GC.UI.Server,本地 HTTP 服务)。
class GcUiApp extends StatefulWidget {
const GcUiApp({super.key});
@override
State<GcUiApp> createState() => _GcUiAppState();
}
class _GcUiAppState extends State<GcUiApp> {
final ShellController _controller = ShellController();
@override
Widget build(BuildContext context) {
// 语言、强调色、主题模式都会触发重建:只重建 MaterialApp 的主题层,
// 不触碰页面状态(页面由 ShellPage 自己持有)。
return ValueListenableBuilder<String>(
valueListenable: I18n.language,
builder: (context, language, _) {
return ValueListenableBuilder<Color>(
valueListenable: GcPalette.accent,
builder: (context, accent, _) {
return ValueListenableBuilder<ThemeMode>(
valueListenable: GcPalette.mode,
builder: (context, mode, _) {
return MaterialApp(
title: 'Morris GC',
debugShowCheckedModeBanner: false,
// 桌面端不要移动端那套拉伸回弹和边缘光晕。
scrollBehavior: const GcScrollBehavior(),
theme: buildGcTheme(Brightness.light),
darkTheme: buildGcTheme(Brightness.dark),
themeMode: mode,
// GcColors 是静态取值,必须按当前实际亮度(含跟随系统)绑定,
// 再用 key 强制子树重建,否则切主题后颜色仍是上一套。
builder: (context, child) {
final brightness = Theme.of(context).brightness;
GcColors.bind(brightness);
return KeyedSubtree(
key: ValueKey<bool>(brightness == Brightness.dark),
child: child ?? const SizedBox.shrink(),
);
},
home: ShellPage(controller: _controller),
);
},
);
},
);
},
);
}
}
-11
View File
@@ -1,11 +0,0 @@
import 'dart:async';
import 'dart:math' as math;
import 'package:flutter/material.dart';
/// 模型通用接口,所有 Flutter 模型实现此接口。
abstract class GcModel {
String get id;
String name();
String description();
Widget buildView(BuildContext context);
}
@@ -1,378 +0,0 @@
import 'dart:math' as math;
import 'package:flutter/material.dart';
import 'base.dart';
import 'contour_model.dart';
/// 等高线模型 Flutter 实现
class ContourModelFlutter implements GcModel {
@override
final String id = 'contour-map-flutter';
@override
String name() => '等高线地形图 (Flutter)';
@override
String description() => '纯 Flutter 实现的等高线地形模型,支持五大地形切换';
@override
Widget buildView(BuildContext context) {
return const _ContourModelView();
}
}
class _ContourModelView extends StatefulWidget {
const _ContourModelView();
@override
State<_ContourModelView> createState() => _ContourModelViewState();
}
class _ContourModelViewState extends State<_ContourModelView>
with TickerProviderStateMixin {
late AnimationController _animController;
TerrainKind _selectedTerrain = TerrainKind.mountain;
bool _isPlaying = false;
bool _colored = false;
bool _isTopView = false;
double _progress = 0;
final List<TerrainKind> _terrains = [
TerrainKind.plain,
TerrainKind.hill,
TerrainKind.mountain,
TerrainKind.plateau,
TerrainKind.basin,
];
@override
void initState() {
super.initState();
_animController = AnimationController(
vsync: this,
duration: const Duration(seconds: 8),
);
}
@override
void dispose() {
_animController.dispose();
super.dispose();
}
void _togglePlay() {
setState(() {
_isPlaying = !_isPlaying;
});
if (_isPlaying) {
_animController.repeat();
} else {
_animController.stop();
}
}
void _reset() {
setState(() {
_isPlaying = false;
_progress = 0;
_colored = false;
_isTopView = false;
});
_animController.stop();
}
void _selectTerrain(TerrainKind terrain) {
setState(() {
_selectedTerrain = terrain;
});
}
@override
Widget build(BuildContext context) {
final isDark = Theme.of(context).brightness == Brightness.dark;
final bgColor = isDark ? const Color(0xFF0B1524) : const Color(0xFFE8F0FE);
final panelColor = isDark ? const Color(0xFF101E31) : const Color(0xFFF5F7FA);
final inkColor = isDark ? const Color(0xFFEAF2FF) : const Color(0xFF111A2E);
final mutedColor = isDark ? const Color(0xFF93A8C6) : const Color(0xFF5C6A80);
return Scaffold(
backgroundColor: bgColor,
body: Column(
children: [
// 标题栏
Container(
padding: const EdgeInsets.symmetric(horizontal: 18, vertical: 12),
color: panelColor,
child: Row(
children: [
Text(
'等高线地形 · 五大地形',
style: TextStyle(
fontSize: 16,
fontWeight: FontWeight.w600,
color: inkColor,
),
),
const Spacer(),
TextButton.icon(
onPressed: _reset,
icon: const Icon(Icons.refresh_rounded, size: 16),
label: const Text('重置'),
),
],
),
),
// 五大地形切换
Container(
padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
color: panelColor,
child: Row(
children: [
Text(
'五大地形:',
style: TextStyle(fontSize: 12, color: mutedColor),
),
const SizedBox(width: 8),
..._terrains.map((t) => _terrainChip(t, _selectedTerrain == t, () => _selectTerrain(t))),
],
),
),
// 画布区域
Expanded(
child: _ContourCanvas(
terrain: _selectedTerrain,
isPlaying: _isPlaying,
progress: _progress,
colored: _colored,
isTopView: _isTopView,
animProgress: _animController.value,
),
),
// 底部控制栏
Container(
padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 12),
color: panelColor,
child: Row(
children: [
_controlBtn(
icon: _isPlaying ? Icons.pause_rounded : Icons.play_arrow_rounded,
label: _isPlaying ? '暂停' : '播放',
color: const Color(0xFF4D8CFF),
onPressed: _togglePlay,
),
const SizedBox(width: 8),
_controlBtn(
icon: Icons.map_rounded,
label: _isTopView ? '立体图' : '俯视图',
color: panelColor,
onPressed: () => setState(() => _isTopView = !_isTopView),
),
const SizedBox(width: 8),
_controlBtn(
icon: Icons.palette_rounded,
label: _colored ? '取消上色' : '上色',
color: _colored ? const Color(0xFF4D8CFF) : panelColor,
onPressed: () => setState(() => _colored = !_colored),
),
const Spacer(),
Expanded(
child: LinearProgressIndicator(
value: _progress,
minHeight: 4,
backgroundColor: isDark ? const Color(0xFF1E3350) : const Color(0xFFE3E8F3),
valueColor: const AlwaysStoppedAnimation<Color>(Color(0xFF4D8CFF)),
),
),
],
),
),
],
),
);
}
Widget _terrainChip(TerrainKind terrain, bool selected, VoidCallback onTap) {
final names = {
TerrainKind.plain: '平原',
TerrainKind.hill: '丘陵',
TerrainKind.mountain: '山地',
TerrainKind.plateau: '高原',
TerrainKind.basin: '盆地',
};
return Padding(
padding: const EdgeInsets.only(right: 6),
child: FilterChip(
label: Text(names[terrain] ?? ''),
selected: selected,
onSelected: (_) => onTap(),
selectedColor: const Color(0xFF4D8CFF).withOpacity(0.2),
checkmarkColor: const Color(0xFF4D8CFF),
),
);
}
Widget _controlBtn({
required IconData icon,
required String label,
required Color color,
required VoidCallback onPressed,
}) {
return TextButton.icon(
onPressed: onPressed,
icon: Icon(icon, size: 16, color: color),
label: Text(label, style: TextStyle(fontSize: 12, color: color)),
);
}
}
/// 等高线画布
class _ContourCanvas extends StatelessWidget {
final TerrainKind terrain;
final bool isPlaying;
final double progress;
final bool colored;
final bool isTopView;
final double animProgress;
const _ContourCanvas({
required this.terrain,
required this.isPlaying,
required this.progress,
required this.colored,
required this.isTopView,
required this.animProgress,
});
@override
Widget build(BuildContext context) {
return CustomPaint(
size: Size.infinite,
painter: _ContourPainter(
terrain: terrain,
isPlaying: isPlaying,
progress: progress,
colored: colored,
isTopView: isTopView,
animProgress: animProgress,
),
);
}
}
class _ContourPainter extends CustomPainter {
final TerrainKind terrain;
final bool isPlaying;
final double progress;
final bool colored;
final bool isTopView;
final double animProgress;
_ContourPainter({
required this.terrain,
required this.isPlaying,
required this.progress,
required this.colored,
required this.isTopView,
required this.animProgress,
});
@override
void paint(Canvas canvas, Size size) {
final bgColor = const Color(0xFF08111E);
final lineColor = const Color(0xFF4D8CFF);
final fillColor = const Color(0xFF1C5FA8);
canvas.drawColor(bgColor, BlendMode.src);
// 绘制等高线
final center = Offset(size.width / 2, size.height / 2);
final radius = math.min(size.width, size.height) * 0.35;
int contourCount;
double maxHeight;
switch (terrain) {
case TerrainKind.plain:
contourCount = 3;
maxHeight = 60;
break;
case TerrainKind.hill:
contourCount = 8;
maxHeight = 180;
break;
case TerrainKind.mountain:
contourCount = 12;
maxHeight = 1200;
break;
case TerrainKind.plateau:
contourCount = 10;
maxHeight = 1250;
break;
case TerrainKind.basin:
contourCount = 10;
maxHeight = 1060;
break;
}
final interval = maxHeight / contourCount;
for (int i = 0; i < contourCount; i++) {
final ratio = (i + 1) / contourCount;
final progressRatio = isPlaying ? animProgress : progress;
if (ratio > progressRatio) continue;
final alpha = colored ? (1 - ratio).clamp(0.2, 1.0) : 1.0;
final paint = Paint()
..color = colored
? fillColor.withOpacity(alpha * 0.3)
: lineColor.withOpacity(alpha)
..style = colored ? PaintingStyle.fill : PaintingStyle.stroke
..strokeWidth = 1.5;
Path path;
if (terrain == TerrainKind.basin) {
final r = radius * ratio;
path = Path()..addOval(Rect.fromCircle(center: center, radius: r));
} else if (terrain == TerrainKind.plateau) {
final r = ratio < 0.5
? radius * 0.5
: radius * (0.5 + (ratio - 0.5) * 0.8);
path = Path()..addOval(Rect.fromCircle(center: center, radius: r));
} else {
final spacing = terrain == TerrainKind.plain ? 0.15 : (terrain == TerrainKind.hill ? 0.1 : 0.08);
final r = radius * (1 - ratio * (1 - spacing));
path = Path()..addOval(Rect.fromCircle(center: center, radius: r));
}
canvas.drawPath(path, paint);
}
// 绘制山峰标记
if (!isTopView && terrain != TerrainKind.plain) {
final peakPaint = Paint()
..color = const Color(0xFFFFD166)
..style = PaintingStyle.fill;
canvas.drawCircle(center, radius * 0.08, peakPaint);
final textPainter = TextPainter(
text: TextSpan(
text: '${maxHeight.toInt()}m',
style: const TextStyle(fontSize: 11, color: Color(0xFFEAF2FF)),
),
textDirection: TextDirection.ltr,
);
textPainter.layout();
textPainter.paint(canvas, Offset(center.dx + 15, center.dy - 20));
}
}
@override
bool shouldRepaint(covariant _ContourPainter oldDelegate) {
return oldDelegate.terrain != terrain ||
oldDelegate.isPlaying != isPlaying ||
oldDelegate.progress != progress ||
oldDelegate.colored != colored ||
oldDelegate.isTopView != isTopView ||
oldDelegate.animProgress != animProgress;
}
}
@@ -1,27 +0,0 @@
/// 五大地形枚举(对应 C# TerrainKind)
enum TerrainKind {
plain, // 平原
hill, // 丘陵
mountain, // 山地
plateau, // 高原
basin, // 盆地
}
/// 五大典型地貌部位(对应 C# LandformKind)
enum LandformKind {
peak, // 山峰
ridge, // 山脊
valley, // 山谷
saddle, // 鞍部
cliff, // 陡崖
}
/// 等高线模型状态
class ContourState {
TerrainKind terrain = TerrainKind.mountain;
LandformKind? selectedLandform;
double progress = 0;
bool isPlaying = false;
bool colored = false;
bool isTopView = false;
}
@@ -1,376 +0,0 @@
import 'dart:math' as math;
import 'package:flutter/material.dart';
import 'base.dart';
import 'geography_model.dart';
/// 地球地理模型 Flutter 实现
class GeographyModelFlutter implements GcModel {
@override
final String id = 'earth-geography-flutter';
@override
String name() => '地球地理 (Flutter)';
@override
String description() => '纯 Flutter 实现的地球地理模型,支持五带划分、七大洲四大洋';
@override
Widget buildView(BuildContext context) {
return const _GeographyModelView();
}
/// 示例数据:五带
List<GeoZone> get defaultZones => [
GeoZone(
id: 'torrid',
nameZh: '热带',
nameEn: 'Torrid Zone',
latMin: -23.5,
latMax: 23.5,
descZh: '南北回归线之间,有太阳直射,终年高温。',
descEn: 'Between the tropics; the Sun is overhead at some time each year.',
),
GeoZone(
id: 'north-temperate',
nameZh: '北温带',
nameEn: 'North Temperate',
latMin: 23.5,
latMax: 66.5,
descZh: '北回归线与北极圈之间,四季分明。',
descEn: 'Between Tropic of Cancer and Arctic Circle; four distinct seasons.',
),
GeoZone(
id: 'south-temperate',
nameZh: '南温带',
nameEn: 'South Temperate',
latMin: -66.5,
latMax: -23.5,
descZh: '南回归线与南极圈之间,四季分明。',
descEn: 'Between Tropic of Capricorn and Antarctic Circle; four seasons.',
),
GeoZone(
id: 'north-frigid',
nameZh: '北寒带',
nameEn: 'North Frigid',
latMin: 66.5,
latMax: 90,
descZh: '北极圈以北,终年寒冷,有极昼极夜。',
descEn: 'Beyond the Arctic Circle; perpetually cold with polar day/night.',
),
GeoZone(
id: 'south-frigid',
nameZh: '南寒带',
nameEn: 'South Frigid',
latMin: -90,
latMax: -66.5,
descZh: '南极圈以南,终年寒冷,有极昼极夜。',
descEn: 'Beyond the Antarctic Circle; perpetually cold with polar day/night.',
),
];
/// 示例数据:五大洲简化轮廓
List<Continent> get defaultContinents => [
Continent(
nameZh: '亚洲',
nameEn: 'Asia',
points: [
[60, 70], [100, 70], [140, 65], [180, 60],
[180, 40], [140, 20], [120, 10], [100, 5],
[80, 10], [60, 20], [50, 30], [40, 40],
],
),
Continent(
nameZh: '非洲',
nameEn: 'Africa',
points: [
[35, 35], [50, 35], [50, 15], [40, 5],
[30, -5], [20, -20], [15, -30], [20, -35],
[30, -35], [35, -25], [40, -10], [35, 5],
],
),
Continent(
nameZh: '欧洲',
nameEn: 'Europe',
points: [
[10, 70], [40, 70], [50, 60], [40, 50],
[30, 45], [20, 45], [10, 50], [0, 55],
],
),
Continent(
nameZh: '北美洲',
nameEn: 'North America',
points: [
[-170, 70], [-130, 70], [-80, 70], [-60, 50],
[-60, 30], [-80, 20], [-100, 20], [-120, 30],
[-160, 50], [-170, 60],
],
),
Continent(
nameZh: '南美洲',
nameEn: 'South America',
points: [
[-80, 10], [-60, 10], [-35, -5], [-35, -20],
[-50, -30], [-65, -50], [-75, -55], [-75, -40],
[-70, -20], [-80, 0],
],
),
Continent(
nameZh: '大洋洲',
nameEn: 'Oceania',
points: [
[115, -15], [150, -15], [160, -25], [150, -35],
[130, -38], [115, -35], [113, -25],
],
),
Continent(
nameZh: '南极洲',
nameEn: 'Antarctica',
points: [
[-180, -65], [-90, -65], [0, -65], [90, -65],
[180, -65], [180, -90], [-180, -90],
],
),
];
}
class _GeographyModelView extends StatefulWidget {
const _GeographyModelView();
@override
State<_GeographyModelView> createState() => _GeographyModelViewState();
}
class _GeographyModelViewState extends State<_GeographyModelView> {
String _activeView = 'zones'; // zones, coast, plates
bool _showZones = true;
bool _showCoast = true;
bool _showPlates = false;
final GeographyModelFlutter _model = GeographyModelFlutter();
@override
Widget build(BuildContext context) {
final isDark = Theme.of(context).brightness == Brightness.dark;
final bgColor = isDark ? const Color(0xFF0B1524) : const Color(0xFFE8F0FE);
final panelColor = isDark ? const Color(0xFF101E31) : const Color(0xFFF5F7FA);
final inkColor = isDark ? const Color(0xFFEAF2FF) : const Color(0xFF111A2E);
return Scaffold(
backgroundColor: bgColor,
body: Column(
children: [
// 标题栏
Container(
padding: const EdgeInsets.symmetric(horizontal: 18, vertical: 12),
color: panelColor,
child: Row(
children: [
Text(
'地球地理 · 五带与七大洲',
style: TextStyle(
fontSize: 16,
fontWeight: FontWeight.w600,
color: inkColor,
),
),
const Spacer(),
_viewButton('五带', _activeView == 'zones', () => setState(() => _activeView = 'zones')),
_viewButton('大洲', _activeView == 'coast', () => setState(() => _activeView = 'coast')),
TextButton.icon(
onPressed: () => setState(() {
_showZones = !_showZones;
_showCoast = !_showCoast;
}),
icon: const Icon(Icons.tune_rounded, size: 16),
label: const Text('图层'),
),
],
),
),
// 地图区域
Expanded(
child: _GeographyMap(
zones: _model.defaultZones,
continents: _model.defaultContinents,
showZones: _showZones,
showCoast: _showCoast,
activeView: _activeView,
),
),
// 底部说明
if (_activeView == 'zones' && _showZones)
Container(
padding: const EdgeInsets.all(12),
color: panelColor,
child: Text(
'热带:南北回归线之间 | 温带:回归线与极圈之间 | 寒带:极圈以内',
style: TextStyle(fontSize: 12, color: isDark ? const Color(0xFF93A8C6) : const Color(0xFF5C6A80)),
textAlign: TextAlign.center,
),
),
],
),
);
}
Widget _viewButton(String label, bool active, VoidCallback onTap) {
return TextButton(
onPressed: onTap,
style: TextButton.styleFrom(
backgroundColor: active ? const Color(0xFF4D8CFF) : null,
foregroundColor: active ? Colors.white : null,
),
child: Text(label, style: const TextStyle(fontSize: 12)),
);
}
}
class _GeographyMap extends StatelessWidget {
final List<GeoZone> zones;
final List<Continent> continents;
final bool showZones;
final bool showCoast;
final String activeView;
const _GeographyMap({
required this.zones,
required this.continents,
required this.showZones,
required this.showCoast,
required this.activeView,
});
@override
Widget build(BuildContext context) {
return CustomPaint(
size: Size.infinite,
painter: _GeographyPainter(
zones: zones,
continents: continents,
showZones: showZones,
showCoast: showCoast,
activeView: activeView,
),
);
}
}
class _GeographyPainter extends CustomPainter {
final List<GeoZone> zones;
final List<Continent> continents;
final bool showZones;
final bool showCoast;
final String activeView;
_GeographyPainter({
required this.zones,
required this.continents,
required this.showZones,
required this.showCoast,
required this.activeView,
});
/// 经纬度转画布坐标
Offset _latLonToOffset(double lon, double lat, Size size) {
final x = (lon + 180) / 360 * size.width;
final y = (90 - lat) / 180 * size.height;
return Offset(x, y);
}
@override
void paint(Canvas canvas, Size size) {
final bgColor = const Color(0xFF0E2A4A);
final oceanColor = const Color(0xFF0E2A4A);
final zoneColors = {
'torrid': const Color(0xFFFF6B35),
'north-temperate': const Color(0xFFFFD93D),
'south-temperate': const Color(0xFF6BCB77),
'north-frigid': const Color(0xFF4D8CFF),
'south-frigid': const Color(0xFF8B5CF6),
};
// 海洋背景
canvas.drawColor(oceanColor, BlendMode.src);
// 绘制五带
if (showZones && activeView == 'zones') {
final bandHeight = size.height / 9; // 180度纬度分9份
final bandColors = [
zoneColors['north-frigid']!,
zoneColors['north-temperate']!,
zoneColors['torrid']!,
zoneColors['south-temperate']!,
zoneColors['south-frigid']!,
];
final bandLatRanges = [
(66.5, 90),
(23.5, 66.5),
(-23.5, 23.5),
(-66.5, -23.5),
(-90, -66.5),
];
for (int i = 0; i < 5; i++) {
final (latMin, latMax) = bandLatRanges[i];
final y1 = (90 - latMax) / 180 * size.height;
final y2 = (90 - latMin) / 180 * size.height;
canvas.drawRect(
Rect.fromLTWH(0, y1, size.width, y2 - y1),
Paint()..color = bandColors[i].withOpacity(0.3),
);
}
// 绘制回归线和极圈
for (final lat in [23.5, -23.5, 66.5, -66.5]) {
final y = (90 - lat) / 180 * size.height;
canvas.drawLine(
Offset(0, y),
Offset(size.width, y),
Paint()
..color = Colors.white.withOpacity(0.4)
..strokeWidth = 1
..style = PaintingStyle.stroke
..style = PaintingStyle.stroke,
);
}
}
// 绘制大陆轮廓
if (showCoast && activeView == 'coast') {
for (final continent in continents) {
if (continent.points.length < 2) continue;
final path = Path();
final start = _latLonToOffset(continent.points[0][0], continent.points[0][1], size);
path.moveTo(start.dx, start.dy);
for (int i = 1; i < continent.points.length; i++) {
final p = _latLonToOffset(continent.points[i][0], continent.points[i][1], size);
path.lineTo(p.dx, p.dy);
}
path.close();
canvas.drawPath(
path,
Paint()
..color = const Color(0xFF4E8C4C)
..style = PaintingStyle.fill,
);
canvas.drawPath(
path,
Paint()
..color = Colors.white.withOpacity(0.6)
..style = PaintingStyle.stroke
..strokeWidth = 1,
);
}
}
}
@override
bool shouldRepaint(covariant _GeographyPainter oldDelegate) {
return oldDelegate.showZones != showZones ||
oldDelegate.showCoast != showCoast ||
oldDelegate.activeView != activeView;
}
}
@@ -1,67 +0,0 @@
import 'package:flutter/material.dart';
/// 地球地理模型数据
class GeoZone {
final String id;
final String nameZh;
final String nameEn;
final double latMin;
final double latMax;
final String descZh;
final String descEn;
GeoZone({
required this.id,
required this.nameZh,
required this.nameEn,
required this.latMin,
required this.latMax,
required this.descZh,
required this.descEn,
});
}
/// 大陆板块数据
class Continent {
final String nameZh;
final String nameEn;
final List<List<double>> points; // [lon, lat]
Continent({
required this.nameZh,
required this.nameEn,
required this.points,
});
}
/// 板块数据
class Plate {
final String id;
final String nameZh;
final String nameEn;
final List<List<double>> points;
Plate({
required this.id,
required this.nameZh,
required this.nameEn,
required this.points,
});
}
/// 洲界线
class Border {
final String betweenZh;
final String betweenEn;
final String nameZh;
final String nameEn;
final List<List<double>> points;
Border({
required this.betweenZh,
required this.betweenEn,
required this.nameZh,
required this.nameEn,
required this.points,
});
}
-37
View File
@@ -1,37 +0,0 @@
/// 模型注册表:所有 Flutter 实现的模型都在这里注册。
library;
export 'base.dart';
export 'contour_model.dart';
export 'contour_flutter.dart';
export 'geography_model.dart';
export 'geography_flutter.dart';
export 'rotation_flutter.dart';
export 'revolution_flutter.dart';
export 'scale_model.dart';
export 'scale_flutter.dart';
import 'base.dart';
import 'contour_flutter.dart';
import 'geography_flutter.dart';
import 'rotation_flutter.dart';
import 'revolution_flutter.dart';
import 'scale_flutter.dart';
/// 所有可用的 Flutter 模型实例。
final List<GcModel> allGcModels = [
ContourModelFlutter(),
GeographyModelFlutter(),
RotationModelFlutter(),
RevolutionModelFlutter(),
ScaleCalculatorModelFlutter(),
];
/// 根据 id 查找模型。
GcModel? findModel(String id) {
try {
return allGcModels.firstWhere((m) => m.id == id);
} catch (_) {
return null;
}
}
@@ -1,252 +0,0 @@
import 'dart:math' as math;
import 'package:flutter/material.dart';
import 'base.dart';
import 'revolution_model.dart';
/// 地球公转模型 Flutter 实现
class RevolutionModelFlutter implements GcModel {
@override
final String id = 'earth-revolution-flutter';
@override
String name() => '地球公转 (Flutter)';
@override
String description() => '纯 Flutter 实现的地球公转模型,观察四季成因';
@override
Widget buildView(BuildContext context) {
return const _RevolutionModelView();
}
List<Season> get defaultSeasons => [
Season(key: 'spring', date: '3/21', declinationDeg: 0, angleDeg: 0,
teachingZh: '太阳直射赤道,全球昼夜平分。', teachingEn: 'Sun overhead at equator.'),
Season(key: 'summer', date: '6/22', declinationDeg: 23.5, angleDeg: 90,
teachingZh: '太阳直射北回归线,北半球昼最长。', teachingEn: 'Sun at Tropic of Cancer.'),
Season(key: 'autumn', date: '9/23', declinationDeg: 0, angleDeg: 180,
teachingZh: '太阳再次直射赤道,昼夜平分。', teachingEn: 'Sun back at equator.'),
Season(key: 'winter', date: '12/22', declinationDeg: -23.5, angleDeg: 270,
teachingZh: '太阳直射南回归线,北半球昼最短。', teachingEn: 'Sun at Tropic of Capricorn.'),
];
}
class _RevolutionModelView extends StatefulWidget {
const _RevolutionModelView();
@override
State<_RevolutionModelView> createState() => _RevolutionModelViewState();
}
class _RevolutionModelViewState extends State<_RevolutionModelView>
with TickerProviderStateMixin {
late AnimationController _orbitController;
bool _isPlaying = true;
double _speed = 1.0;
int _selectedSeason = 0;
@override
void initState() {
super.initState();
_orbitController = AnimationController(
vsync: this,
duration: const Duration(seconds: 12),
)..repeat();
}
@override
void dispose() {
_orbitController.dispose();
super.dispose();
}
void _togglePlay() {
setState(() => _isPlaying = !_isPlaying);
if (_isPlaying) _orbitController.repeat();
else _orbitController.stop();
}
void _reset() {
setState(() {
_isPlaying = true;
_speed = 1.0;
_selectedSeason = 0;
});
_orbitController.repeat();
}
@override
Widget build(BuildContext context) {
final isDark = Theme.of(context).brightness == Brightness.dark;
final bgColor = isDark ? const Color(0xFF0B1524) : const Color(0xFFE8F0FE);
final panelColor = isDark ? const Color(0xFF101E31) : const Color(0xFFF5F7FA);
final inkColor = isDark ? const Color(0xFFEAF2FF) : const Color(0xFF111A2E);
return Scaffold(
backgroundColor: bgColor,
body: Column(
children: [
Container(
padding: const EdgeInsets.symmetric(horizontal: 18, vertical: 12),
color: panelColor,
child: Row(
children: [
Text('地球公转 · 四季成因', style: TextStyle(fontSize: 16, fontWeight: FontWeight.w600, color: inkColor)),
const Spacer(),
...['春分', '夏至', '秋分', '冬至'].asMap().entries.map((e) =>
Padding(padding: const EdgeInsets.only(left: 6),
child: FilterChip(
label: Text(e.value, style: const TextStyle(fontSize: 11)),
selected: _selectedSeason == e.key,
onSelected: (_) => setState(() => _selectedSeason = e.key),
selectedColor: const Color(0xFF4D8CFF).withOpacity(0.2),
),
),
),
],
),
),
Expanded(
child: _RevolutionOrbit(
progress: _orbitController.value,
selectedSeason: _selectedSeason,
),
),
Container(
padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 12),
color: panelColor,
child: Row(
children: [
IconButton(onPressed: _togglePlay, icon: Icon(_isPlaying ? Icons.pause_rounded : Icons.play_arrow_rounded), color: const Color(0xFF4D8CFF)),
const SizedBox(width: 16),
Text('速度:', style: TextStyle(fontSize: 12, color: isDark ? const Color(0xFF93A8C6) : const Color(0xFF5C6A80))),
const SizedBox(width: 8),
Expanded(child: Slider(value: _speed, min: 0.1, max: 3.0, divisions: 29, onChanged: (v) => setState(() => _speed = v))),
Text('${_speed.toStringAsFixed(1)}x'),
const Spacer(),
TextButton.icon(onPressed: _reset, icon: const Icon(Icons.refresh_rounded, size: 16), label: const Text('重置')),
],
),
),
],
),
);
}
}
class _RevolutionOrbit extends StatelessWidget {
final double progress;
final int selectedSeason;
const _RevolutionOrbit({required this.progress, required this.selectedSeason});
@override
Widget build(BuildContext context) {
return CustomPaint(
size: Size.infinite,
painter: _RevolutionPainter(progress: progress, selectedSeason: selectedSeason),
);
}
}
class _RevolutionPainter extends CustomPainter {
final double progress;
final int selectedSeason;
_RevolutionPainter({required this.progress, required this.selectedSeason});
@override
void paint(Canvas canvas, Size size) {
final bgColor = const Color(0xFF08111E);
final sunColor = const Color(0xFFFFC24B);
final orbitColor = const Color(0xFF4D8CFF);
final earthColor = const Color(0xFF1C5FA8);
canvas.drawColor(bgColor, BlendMode.src);
final center = Offset(size.width / 2, size.height / 2);
final orbitRadius = math.min(size.width, size.height) * 0.35;
// 绘制轨道
canvas.drawCircle(center, orbitRadius, Paint()
..color = orbitColor.withOpacity(0.3)
..style = PaintingStyle.stroke
..strokeWidth = 1.5
..style = PaintingStyle.stroke);
// 绘制太阳
canvas.drawCircle(center, 30, Paint()
..color = sunColor
..style = PaintingStyle.fill);
// 太阳发光效果
for (int i = 4; i > 0; i--) {
canvas.drawCircle(center, 30 + i * 12, Paint()
..color = sunColor.withOpacity(0.1 * (5 - i))
..style = PaintingStyle.fill);
}
// 绘制地球位置(根据进度)
final angle = progress * 2 * math.pi;
final earthX = center.dx + math.cos(angle) * orbitRadius;
final earthY = center.dy + math.sin(angle) * orbitRadius;
// 地球
canvas.drawCircle(Offset(earthX, earthY), 15, Paint()
..color = earthColor
..style = PaintingStyle.fill);
// 地轴(倾斜23.5度)
final tiltAngle = 23.5 * math.pi / 180;
canvas.drawLine(
Offset(earthX - math.sin(tiltAngle) * 25, earthY - math.cos(tiltAngle) * 25),
Offset(earthX + math.sin(tiltAngle) * 25, earthY + math.cos(tiltAngle) * 25),
Paint()
..color = const Color(0xFFFF6B35)
..strokeWidth = 2
..style = PaintingStyle.stroke);
// 标注四个关键位置
final seasonLabels = ['春分', '夏至', '秋分', '冬至'];
final seasonColors = [const Color(0xFF6BCB77), const Color(0xFFFFD93D), const Color(0xFF4D8CFF), const Color(0xFF8B5CF6)];
for (int i = 0; i < 4; i++) {
final seasonAngle = i * math.pi / 2;
final sx = center.dx + math.cos(seasonAngle) * orbitRadius;
final sy = center.dy + math.sin(seasonAngle) * orbitRadius;
// 小圆点标记
canvas.drawCircle(Offset(sx, sy), 5, Paint()
..color = seasonColors[i]
..style = PaintingStyle.fill);
// 标签
final labelX = sx + math.cos(seasonAngle) * 25;
final labelY = sy + math.sin(seasonAngle) * 25;
final textPainter = TextPainter(
text: TextSpan(text: seasonLabels[i], style: const TextStyle(fontSize: 10, color: Color(0xFFEAF2FF))),
textDirection: TextDirection.ltr,
);
textPainter.layout();
textPainter.paint(canvas, Offset(labelX - 15, labelY - 8));
}
// 当前选中季节高亮
if (selectedSeason >= 0 && selectedSeason < 4) {
final selAngle = selectedSeason * math.pi / 2;
final selX = center.dx + math.cos(selAngle) * orbitRadius;
final selY = center.dy + math.sin(selAngle) * orbitRadius;
canvas.drawCircle(Offset(selX, selY), 8, Paint()
..color = seasonColors[selectedSeason].withOpacity(0.5)
..style = PaintingStyle.stroke
..strokeWidth = 2);
}
}
@override
bool shouldRepaint(covariant _RevolutionPainter oldDelegate) {
return oldDelegate.progress != progress || oldDelegate.selectedSeason != selectedSeason;
}
}
@@ -1,39 +0,0 @@
import 'package:flutter/material.dart';
/// 节气数据
class Season {
final String key;
final String date;
final double declinationDeg;
final double angleDeg;
final String teachingZh;
final String teachingEn;
Season({
required this.key,
required this.date,
required this.declinationDeg,
required this.angleDeg,
required this.teachingZh,
required this.teachingEn,
});
}
/// 教学要点
class Lesson {
final String titleZh;
final String titleEn;
final String bodyZh;
final String bodyEn;
final String view;
final double? angleDeg;
Lesson({
required this.titleZh,
required this.titleEn,
required this.bodyZh,
required this.bodyEn,
required this.view,
this.angleDeg,
});
}
@@ -1,330 +0,0 @@
import 'dart:math' as math;
import 'package:flutter/material.dart';
import 'base.dart';
/// 地球自转模型 Flutter 实现
class RotationModelFlutter implements GcModel {
@override
final String id = 'earth-rotation-flutter';
@override
String name() => '地球自转 (Flutter)';
@override
String description() => '纯 Flutter 实现的地球自转模型,观察昼夜交替、晨昏线';
@override
Widget buildView(BuildContext context) {
return const _RotationModelView();
}
}
class _RotationModelView extends StatefulWidget {
const _RotationModelView();
@override
State<_RotationModelView> createState() => _RotationModelViewState();
}
class _RotationModelViewState extends State<_RotationModelView>
with TickerProviderStateMixin {
late AnimationController _spinController;
late AnimationController _tiltController;
bool _isPlaying = true;
double _speed = 1.0;
bool _showLabels = true;
bool _showTilt = false;
@override
void initState() {
super.initState();
_spinController = AnimationController(
vsync: this,
duration: const Duration(seconds: 10),
)..repeat();
_tiltController = AnimationController(
vsync: this,
duration: const Duration(milliseconds: 500),
);
}
@override
void dispose() {
_spinController.dispose();
_tiltController.dispose();
super.dispose();
}
void _togglePlay() {
setState(() {
_isPlaying = !_isPlaying;
});
if (_isPlaying) {
_spinController.repeat();
} else {
_spinController.stop();
}
}
void _reset() {
setState(() {
_isPlaying = true;
_speed = 1.0;
_showLabels = true;
_showTilt = false;
});
_spinController.repeat();
_tiltController.reset();
}
@override
Widget build(BuildContext context) {
final isDark = Theme.of(context).brightness == Brightness.dark;
final bgColor = isDark ? const Color(0xFF0B1524) : const Color(0xFFE8F0FE);
final panelColor = isDark ? const Color(0xFF101E31) : const Color(0xFFF5F7FA);
final inkColor = isDark ? const Color(0xFFEAF2FF) : const Color(0xFF111A2E);
return Scaffold(
backgroundColor: bgColor,
body: Column(
children: [
// 标题栏
Container(
padding: const EdgeInsets.symmetric(horizontal: 18, vertical: 12),
color: panelColor,
child: Row(
children: [
Text(
'地球自转 · 昼夜交替',
style: TextStyle(
fontSize: 16,
fontWeight: FontWeight.w600,
color: inkColor,
),
),
const Spacer(),
_toggleButton('标注', _showLabels, () => setState(() => _showLabels = !_showLabels)),
_toggleButton('倾角', _showTilt, () => setState(() => _showTilt = !_showTilt)),
const SizedBox(width: 8),
TextButton.icon(
onPressed: _reset,
icon: const Icon(Icons.refresh_rounded, size: 16),
label: const Text('重置'),
),
],
),
),
// 地球动画
Expanded(
child: _RotationEarth(
animProgress: _spinController.value,
showLabels: _showLabels,
showTilt: _showTilt,
isPlaying: _isPlaying,
),
),
// 底部控制栏
Container(
padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 12),
color: panelColor,
child: Row(
children: [
IconButton(
onPressed: _togglePlay,
icon: Icon(_isPlaying ? Icons.pause_rounded : Icons.play_arrow_rounded),
color: const Color(0xFF4D8CFF),
),
const SizedBox(width: 16),
Text('速度:', style: TextStyle(fontSize: 12, color: isDark ? const Color(0xFF93A8C6) : const Color(0xFF5C6A80))),
const SizedBox(width: 8),
Expanded(
child: Slider(
value: _speed,
min: 0.1,
max: 3.0,
divisions: 29,
onChanged: (v) => setState(() => _speed = v),
),
),
Text('${_speed.toStringAsFixed(1)}x', style: const TextStyle(fontSize: 12)),
],
),
),
],
),
);
}
Widget _toggleButton(String label, bool active, VoidCallback onTap) {
return Padding(
padding: const EdgeInsets.only(left: 8),
child: FilterChip(
label: Text(label, style: const TextStyle(fontSize: 12)),
selected: active,
onSelected: (_) => onTap(),
selectedColor: const Color(0xFF4D8CFF).withOpacity(0.2),
checkmarkColor: const Color(0xFF4D8CFF),
),
);
}
}
class _RotationEarth extends StatelessWidget {
final double animProgress;
final bool showLabels;
final bool showTilt;
final bool isPlaying;
const _RotationEarth({
required this.animProgress,
required this.showLabels,
required this.showTilt,
required this.isPlaying,
});
@override
Widget build(BuildContext context) {
return CustomPaint(
size: Size.infinite,
painter: _RotationPainter(
animProgress: animProgress,
showLabels: showLabels,
showTilt: showTilt,
isPlaying: isPlaying,
),
);
}
}
class _RotationPainter extends CustomPainter {
final double animProgress;
final bool showLabels;
final bool showTilt;
final bool isPlaying;
_RotationPainter({
required this.animProgress,
required this.showLabels,
required this.showTilt,
required this.isPlaying,
});
@override
void paint(Canvas canvas, Size size) {
final bgColor = const Color(0xFF08111E);
final earthColor = const Color(0xFF1C5FA8);
final landColor = const Color(0xFF4E8C4C);
final iceColor = const Color(0xFFE9EFF6);
final axisColor = const Color(0xFFFF6B35);
final labelColor = const Color(0xFFEAF2FF);
canvas.drawColor(bgColor, BlendMode.src);
final center = Offset(size.width / 2, size.height / 2);
final radius = math.min(size.width, size.height) * 0.3;
// 绘制地球球体
final earthPaint = Paint()
..color = earthColor
..style = PaintingStyle.fill;
canvas.drawCircle(center, radius, earthPaint);
// 绘制大陆(简化版,用椭圆模拟)
final continents = [
(center.dx - radius * 0.3, center.dy - radius * 0.2, radius * 0.25, radius * 0.35), // 亚洲
(center.dx + radius * 0.2, center.dy - radius * 0.1, radius * 0.2, radius * 0.25), // 欧洲
(center.dx - radius * 0.1, center.dy + radius * 0.2, radius * 0.15, radius * 0.3), // 非洲
(center.dx + radius * 0.35, center.dy + radius * 0.1, radius * 0.2, radius * 0.25), // 北美
(center.dx + radius * 0.3, center.dy + radius * 0.4, radius * 0.15, radius * 0.2), // 南美
];
for (final cont in continents) {
canvas.drawOval(
Rect.fromLTWH(cont.$1 - cont.$3 / 2, cont.$2 - cont.$4 / 2, cont.$3, cont.$4),
Paint()..color = landColor,
);
}
// 绘制极冰
canvas.drawOval(
Rect.fromLTWH(center.dx - radius * 0.15, center.dy - radius * 0.95, radius * 0.3, radius * 0.15),
Paint()..color = iceColor,
);
canvas.drawOval(
Rect.fromLTWH(center.dx - radius * 0.15, center.dy + radius * 0.8, radius * 0.3, radius * 0.15),
Paint()..color = iceColor,
);
// 绘制地轴
if (showTilt) {
final tiltAngle = 23.5 * math.pi / 180;
final axisLength = radius * 1.4;
final topY = center.dy - axisLength / 2;
final bottomY = center.dy + axisLength / 2;
final offsetX = math.sin(tiltAngle) * axisLength / 2;
canvas.drawLine(
Offset(center.dx - offsetX, topY),
Offset(center.dx + offsetX, bottomY),
Paint()
..color = axisColor
..strokeWidth = 2
..style = PaintingStyle.stroke,
);
// 北极标注
if (showLabels) {
final textPainter = TextPainter(
text: const TextSpan(text: '北极', style: TextStyle(fontSize: 11, color: Color(0xFFFF6B35))),
textDirection: TextDirection.ltr,
);
textPainter.layout();
textPainter.paint(canvas, Offset(center.dx + offsetX + 10, topY - 5));
}
}
// 绘制晨昏线(昼夜分界)
final sunAngle = animProgress * 2 * math.pi;
final terminatorX = center.dx + math.cos(sunAngle) * radius * 0.3;
// 昼半球高光
final dayPaint = Paint()
..color = Colors.yellow.withOpacity(0.15)
..style = PaintingStyle.fill;
canvas.drawCircle(
Offset(terminatorX + math.cos(sunAngle) * radius * 0.3, center.dy),
radius * 0.9,
dayPaint,
);
// 标注直射点
if (showLabels) {
final subsolarX = center.dx + math.cos(sunAngle) * radius;
final subsolarY = center.dy + math.sin(sunAngle * 0.3) * radius * 0.5;
// 太阳光线
canvas.drawLine(
Offset(subsolarX + math.cos(sunAngle) * 20, subsolarY + math.sin(sunAngle) * 20),
Offset(subsolarX + math.cos(sunAngle) * 50, subsolarY + math.sin(sunAngle) * 50),
Paint()
..color = const Color(0xFFFFC24B)
..strokeWidth = 2
..style = PaintingStyle.stroke,
);
final textPainter = TextPainter(
text: const TextSpan(text: '直射点', style: TextStyle(fontSize: 10, color: Color(0xFFFFC24B))),
textDirection: TextDirection.ltr,
);
textPainter.layout();
textPainter.paint(canvas, Offset(subsolarX + 15, subsolarY - 10));
}
}
@override
bool shouldRepaint(covariant _RotationPainter oldDelegate) {
return oldDelegate.animProgress != animProgress ||
oldDelegate.showLabels != showLabels ||
oldDelegate.showTilt != showTilt;
}
}
@@ -1,217 +0,0 @@
import 'package:flutter/material.dart';
import 'base.dart';
import 'scale_model.dart';
class ScaleCalculatorModelFlutter implements GcModel {
@override
final String id = 'scale-calculator-flutter';
@override
String name() => '比例尺计算器 (Flutter)';
@override
String description() => '纯 Flutter 实现的比例尺计算器';
@override
Widget buildView(BuildContext context) => const _ScaleCalculatorView();
List<ScalePreset> get presets => [
ScalePreset(n: 10000, nameKey: 'preset.campus', noteKey: 'preset.campusNote'),
ScalePreset(n: 50000, nameKey: 'preset.town', noteKey: 'preset.townNote'),
ScalePreset(n: 250000, nameKey: 'preset.city', noteKey: 'preset.cityNote'),
ScalePreset(n: 1000000, nameKey: 'preset.province', noteKey: 'preset.provinceNote'),
ScalePreset(n: 10000000, nameKey: 'preset.china', noteKey: 'preset.chinaNote'),
ScalePreset(n: 100000000, nameKey: 'preset.world', noteKey: 'preset.worldNote'),
];
List<ScaleSpectrum> get spectrum => [
ScaleSpectrum(n: 10000, labelKey: 'spec.campus', scopeKey: 'spec.campusScope'),
ScaleSpectrum(n: 250000, labelKey: 'spec.city', scopeKey: 'spec.cityScope'),
ScaleSpectrum(n: 10000000, labelKey: 'spec.china', scopeKey: 'spec.chinaScope'),
ScaleSpectrum(n: 100000000, labelKey: 'spec.world', scopeKey: 'spec.worldScope'),
];
List<Landmark> get landmarks => [
Landmark(nameKey: 'lm.classroom', meters: 10),
Landmark(nameKey: 'lm.track', meters: 400),
Landmark(nameKey: 'lm.marathon', meters: 42195),
Landmark(nameKey: 'lm.beijingShanghai', meters: 1080000),
Landmark(nameKey: 'lm.equator', meters: 40000000),
];
}
class _ScaleCalculatorView extends StatefulWidget {
const _ScaleCalculatorView();
@override
State<_ScaleCalculatorView> createState() => _ScaleCalculatorViewState();
}
class _ScaleCalculatorViewState extends State<_ScaleCalculatorView> {
String _mode = 'real';
double _mapDist = 10;
double _realDist = 100000;
double _scaleN = 10000.0;
String _unit = 'cm';
@override
Widget build(BuildContext context) {
final isDark = Theme.of(context).brightness == Brightness.dark;
final bgColor = isDark ? const Color(0xFF0B1524) : const Color(0xFFE8F0FE);
final panelColor = isDark ? const Color(0xFF101E31) : const Color(0xFFF5F7FA);
final inkColor = isDark ? const Color(0xFFEAF2FF) : const Color(0xFF111A2E);
return Scaffold(
backgroundColor: bgColor,
body: Column(
children: [
Container(
padding: const EdgeInsets.symmetric(horizontal: 18, vertical: 12),
color: panelColor,
child: Row(
children: [
Text('比例尺计算器', style: TextStyle(fontSize: 16, fontWeight: FontWeight.w600, color: inkColor)),
const Spacer(),
_modeBtn('求实地距离', _mode == 'real'),
_modeBtn('求图上距离', _mode == 'map'),
_modeBtn('求比例尺', _mode == 'scale'),
],
),
),
Expanded(
child: _ScaleCanvas(
mode: _mode,
mapDist: _mapDist,
realDist: _realDist,
scaleN: _scaleN,
unit: _unit,
),
),
Container(
padding: const EdgeInsets.all(16),
color: panelColor,
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Text('已知量:', style: TextStyle(fontSize: 12, color: isDark ? const Color(0xFF93A8C6) : const Color(0xFF5C6A80))),
const SizedBox(height: 8),
Row(
children: [
Expanded(
child: TextField(
decoration: const InputDecoration(labelText: '图上距离 (cm)'),
keyboardType: TextInputType.number,
onChanged: (v) => setState(() => _mapDist = double.tryParse(v) ?? 0),
),
),
const SizedBox(width: 8),
Expanded(
child: TextField(
decoration: const InputDecoration(labelText: '比例尺 N'),
keyboardType: TextInputType.number,
onChanged: (v) => setState(() => _scaleN = double.tryParse(v) ?? 10000.0),
),
),
],
),
const SizedBox(height: 8),
Row(
children: [
Text('结果:', style: TextStyle(fontSize: 12, color: isDark ? const Color(0xFF93A8C6) : const Color(0xFF5C6A80))),
const SizedBox(width: 8),
Text('实地距离 = ${(_mapDist * _scaleN / 100).toStringAsFixed(2)} m', style: const TextStyle(fontSize: 14, fontWeight: FontWeight.w600, color: Color(0xFF4D8CFF))),
],
),
],
),
),
],
),
);
}
Widget _modeBtn(String label, bool active) {
return Padding(
padding: const EdgeInsets.only(left: 6),
child: FilterChip(
label: Text(label, style: const TextStyle(fontSize: 12)),
selected: active,
onSelected: (_) => setState(() => _mode = active ? 'real' : 'real'),
selectedColor: const Color(0xFF4D8CFF).withOpacity(0.2),
),
);
}
}
class _ScaleCanvas extends StatelessWidget {
final String mode;
final double mapDist;
final double realDist;
final double scaleN;
final String unit;
const _ScaleCanvas({required this.mode, required this.mapDist, required this.realDist, required this.scaleN, required this.unit});
@override
Widget build(BuildContext context) {
return CustomPaint(
size: Size.infinite,
painter: _ScalePainter(mode: mode, mapDist: mapDist, realDist: realDist, scaleN: scaleN, unit: unit),
);
}
}
class _ScalePainter extends CustomPainter {
final String mode;
final double mapDist;
final double realDist;
final double scaleN;
final String unit;
_ScalePainter({required this.mode, required this.mapDist, required this.realDist, required this.scaleN, required this.unit});
@override
void paint(Canvas canvas, Size size) {
final isDark = true;
final bgColor = const Color(0xFF08111E);
final barColor = const Color(0xFF4D8CFF);
final inkColor = const Color(0xFFEAF2FF);
canvas.drawColor(bgColor, BlendMode.src);
final centerY = size.height / 2;
final double barHeight = 40.0;
final barY = centerY - barHeight / 2;
final maxBarWidth = size.width * 0.8;
final startX = (size.width - maxBarWidth) / 2;
// 绘制标尺
canvas.drawRRect(
RRect.fromRectAndRadius(Rect.fromLTWH(startX, barY, maxBarWidth, barHeight), Radius.circular(4.0)),
Paint()..color = barColor.withOpacity(0.2),
);
// 刻度
final double tickCount = 20.0;
for (int i = 0; i <= tickCount; i++) {
final x = startX + (maxBarWidth * i / tickCount);
final double tickHeight = i % 5 == 0 ? 15.0 : 8.0;
canvas.drawLine(
Offset(x, barY + (barHeight - tickHeight) / 2),
Offset(x, barY + (barHeight + tickHeight) / 2),
Paint()
..color = inkColor
..strokeWidth = 1,
);
}
// 数值标注
final textPainter = TextPainter(
text: TextSpan(text: '1 : $scaleN', style: const TextStyle(fontSize: 14, fontWeight: FontWeight.w600, color: Color(0xFF4D8CFF))),
textDirection: TextDirection.ltr,
);
textPainter.layout();
textPainter.paint(canvas, Offset(size.width / 2 - 40, barY + barHeight + 16));
}
@override
bool shouldRepaint(covariant _ScalePainter oldDelegate) {
return oldDelegate.mode != mode || oldDelegate.scaleN != scaleN;
}
}
@@ -1,27 +0,0 @@
import 'package:flutter/material.dart';
/// 比例尺预设
class ScalePreset {
final int n;
final String nameKey;
final String noteKey;
ScalePreset({required this.n, required this.nameKey, required this.noteKey});
}
/// 比例尺光谱
class ScaleSpectrum {
final int n;
final String labelKey;
final String scopeKey;
ScaleSpectrum({required this.n, required this.labelKey, required this.scopeKey});
}
/// 真实地标
class Landmark {
final String nameKey;
final double meters;
Landmark({required this.nameKey, required this.meters});
}
-8
View File
@@ -1,8 +0,0 @@
// 页面聚合导出:四个页面按职责拆到 pages/ 子目录。
// 保留这个文件是为了让 shell.dart 等调用方的 import 路径不变。
export 'pages/home.dart';
export 'pages/courseware.dart';
export 'pages/download.dart';
export 'pages/settings.dart';
export 'pages/about.dart';
-405
View File
@@ -1,405 +0,0 @@
import 'dart:async';
import 'package:flutter/material.dart';
import '../api_client.dart';
import '../controller.dart';
import '../i18n.dart';
import '../theme.dart';
// ---------------------------------------------------------------------------
// 关于页(从原 pages.dart 拆出,公开类名不变)
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
// 关于页
// ---------------------------------------------------------------------------
class AboutPageView extends StatefulWidget {
const AboutPageView({super.key, required this.controller, this.initialAbout});
final ShellController controller;
/// 预置数据(仅用于测试 / 截图,正常运行时为 null,由后端提供)。
final AboutInfo? initialAbout;
@override
State<AboutPageView> createState() => _AboutPageViewState();
}
class _AboutPageViewState extends State<AboutPageView> {
AboutInfo? _about;
bool _loading = true;
String? _error;
@override
void initState() {
super.initState();
final preset = widget.initialAbout;
if (preset != null) {
_about = preset;
_loading = false;
return;
}
_load();
}
Future<void> _load() async {
setState(() {
_loading = true;
_error = null;
});
try {
final about = await widget.controller.api.about();
if (!mounted) return;
setState(() {
_about = about;
_loading = false;
});
} catch (error) {
if (!mounted) return;
setState(() {
_error = error.toString();
_loading = false;
});
}
}
@override
Widget build(BuildContext context) {
return ListView(
padding: const EdgeInsets.fromLTRB(
GcSpace.xxl,
GcSpace.xxl,
GcSpace.xxl,
GcSpace.xxxl,
),
children: <Widget>[
GcPageHeader(
title: T('nav.about'),
subtitle: T('app.tagline'),
),
const SizedBox(height: GcSpace.xxl),
if (_loading)
const Padding(
padding: EdgeInsets.symmetric(vertical: 48),
child: Center(
child: SizedBox(
width: 22,
height: 22,
child: CircularProgressIndicator(strokeWidth: 2),
),
),
)
else if (_error != null)
GcMessage(
title: T('common.error'),
message: _error,
icon: Icons.error_outline_rounded,
color: GcColors.danger,
action: OutlinedButton(
onPressed: _load,
child: Text(T('common.retry')),
),
)
else ...<Widget>[
_versionCard(),
const SizedBox(height: GcSpace.lg),
_contributorsCard(),
const SizedBox(height: GcSpace.lg),
_thanksCard(),
],
],
);
}
Widget _versionCard() {
final about = _about;
// 左边身份卡、右边信息表:宽屏两栏,窄屏自动堆叠。
final identity = Column(
crossAxisAlignment: CrossAxisAlignment.start,
mainAxisSize: MainAxisSize.min,
children: <Widget>[
Row(
children: <Widget>[
Container(
width: 44,
height: 44,
alignment: Alignment.center,
decoration: BoxDecoration(
color: GcColors.accentSoft,
borderRadius: BorderRadius.circular(GcRadius.card),
),
child: Text(
'◎',
style: TextStyle(
fontSize: 22, height: 1.1, color: GcColors.accent),
),
),
const SizedBox(width: GcSpace.lg),
Expanded(
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
mainAxisSize: MainAxisSize.min,
children: <Widget>[
Text(
about?.appName ?? 'Morris GC',
style: TextStyle(
fontSize: 20,
height: 1.3,
fontWeight: FontWeight.w600,
color: GcColors.ink,
),
),
const SizedBox(height: 2),
Text(
T('app.tagline'),
style: TextStyle(
fontSize: 12.5,
height: 1.5,
color: GcColors.faint,
),
),
],
),
),
],
),
const SizedBox(height: GcSpace.lg),
Wrap(
spacing: GcSpace.sm,
runSpacing: GcSpace.sm,
children: <Widget>[
GcPill('v${about?.version ?? '—'}', color: GcColors.accent),
],
),
const SizedBox(height: GcSpace.lg),
OutlinedButton(
onPressed: () async {
final url = about?.repository;
if (url == null || url.isEmpty) return;
try {
await widget.controller.api.openUrl(url);
} catch (_) {
// 忽略
}
},
child: Text(T('about.openRepository')),
),
],
);
final details = Column(
crossAxisAlignment: CrossAxisAlignment.stretch,
mainAxisSize: MainAxisSize.min,
children: <Widget>[
GcFieldRow(
label: T('set.platform'),
value: about?.platform ?? '—',
),
GcFieldRow(
label: T('about.architecture'),
value: T('about.architectureValue'),
),
GcFieldRow(
label: T('about.sourceLanguage'),
value: about?.sourceLanguage ?? 'C#',
),
GcFieldRow(
label: T('about.frontend'),
value: about?.frontend ?? 'Flutter',
),
GcFieldRow(
label: T('about.gitService'),
value: 'itxiaohui',
),
GcFieldRow(
label: T('set.license'),
value: T('set.licenseValue'),
),
],
);
return GcCard(
padding: const EdgeInsets.all(GcSpace.xxl),
child: LayoutBuilder(
builder: (context, constraints) {
if (constraints.maxWidth < 720) {
return Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
identity,
const GcDivider(verticalPadding: GcSpace.lg),
details,
],
);
}
return Row(
crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
Expanded(flex: 4, child: identity),
const SizedBox(width: GcSpace.xxxl),
Expanded(flex: 5, child: details),
],
);
},
),
);
}
Widget _contributorsCard() {
final contributors = _about?.contributors ?? const <ContributorInfo>[];
return GcCard(
padding: const EdgeInsets.all(GcSpace.xxl),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
GcSectionTitle(
T('about.developers'),
subtitle: T('about.contributorsHint'),
),
const SizedBox(height: GcSpace.lg),
if (contributors.isEmpty)
GcHint(T('about.noContributors'))
else
Wrap(
spacing: GcSpace.xl,
runSpacing: GcSpace.md,
children: <Widget>[
for (final contributor in contributors)
SizedBox(
width: 220,
child: Row(
children: <Widget>[
CircleAvatar(
radius: 18,
backgroundColor: GcColors.surfaceAlt,
backgroundImage: contributor.avatarUrl == null
? null
: NetworkImage(contributor.avatarUrl!),
child: contributor.avatarUrl == null
? Text(
'◎',
style: TextStyle(
fontSize: 14,
color: GcColors.accent,
),
)
: null,
),
const SizedBox(width: GcSpace.md),
Expanded(
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
mainAxisSize: MainAxisSize.min,
children: <Widget>[
Text(
contributor.name,
maxLines: 1,
overflow: TextOverflow.ellipsis,
style: TextStyle(
fontSize: 13,
height: 1.4,
fontWeight: FontWeight.w600,
color: GcColors.ink,
),
),
Text(
T(
'about.contributions',
<Object?>[contributor.contributions],
),
style: TextStyle(
fontSize: 11.5,
height: 1.4,
color: GcColors.faint,
),
),
],
),
),
],
),
),
],
),
],
),
);
}
/// 特别感谢:与「开发者」分开列 —— 提供 Git 服务不等于往仓库提交代码,
/// 混进贡献者列表会让提交数失去意义。
Widget _thanksCard() {
return GcCard(
padding: const EdgeInsets.all(GcSpace.xxl),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
GcSectionTitle(
T('about.thanks'),
subtitle: T('about.thanksHint'),
),
const SizedBox(height: GcSpace.lg),
Wrap(
spacing: GcSpace.xl,
runSpacing: GcSpace.md,
children: <Widget>[
_creditTile('地理洪老师', 'about.thanksGeo'),
_creditTile('itxiaohui', 'about.thanksGit'),
],
),
],
),
);
}
Widget _creditTile(String name, String roleKey) {
return SizedBox(
width: 220,
child: Row(
children: <Widget>[
CircleAvatar(
radius: 18,
backgroundColor: GcColors.surfaceAlt,
child: Text(
'◎',
style: TextStyle(fontSize: 14, color: GcColors.accent),
),
),
const SizedBox(width: GcSpace.md),
Expanded(
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
mainAxisSize: MainAxisSize.min,
children: <Widget>[
Text(
name,
maxLines: 1,
overflow: TextOverflow.ellipsis,
style: TextStyle(
fontSize: 13,
height: 1.4,
fontWeight: FontWeight.w600,
color: GcColors.ink,
),
),
Text(
T(roleKey),
maxLines: 1,
overflow: TextOverflow.ellipsis,
style: TextStyle(
fontSize: 11.5,
height: 1.4,
color: GcColors.faint,
),
),
],
),
),
],
),
);
}
}
-294
View File
@@ -1,294 +0,0 @@
import 'dart:async';
import 'dart:io';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:flutter_inappwebview/flutter_inappwebview.dart';
import '../theme.dart';
/// 等高线课件页:用 WebView 承载去除授权验证后的离线 HTML 课件。
///
/// 资源(index.html + assets/)作为 Flutter assets 打包。桌面 WebView 不能直接
/// 读 flutter assets,因此用一个仅监听 127.0.0.1 的静态服务器(端口 0 自动分配,
/// 不与后端/其他进程冲突)把 assets 暴露成 http://127.0.0.1:<port>/ 再交给
/// WebView 加载。图片、视频、Three.js 与全部交互都保持原课件原样。
class CoursewarePage extends StatefulWidget {
const CoursewarePage({super.key});
@override
State<CoursewarePage> createState() => _CoursewarePageState();
}
class _CoursewarePageState extends State<CoursewarePage>
with AutomaticKeepAliveClientMixin {
@override
bool get wantKeepAlive => true;
HttpServer? _server;
int? _port;
InAppWebViewController? _controller;
double _progress = 0;
String? _error;
Directory? _extractDir;
/// 打包后的 app 工作目录不固定,不能直接用相对路径读 flutter assets。
/// 首次进入时把课件资源解压到临时目录,服务器再从这里提供文件。
Future<Directory> _extractAssets() async {
final dir = await Directory.systemTemp.createTemp('gc-courseware-');
final manifest = await AssetManifest.loadFromAssetBundle(rootBundle);
const prefix = 'courseware/';
for (final key in manifest.listAssets()) {
if (!key.startsWith(prefix)) continue;
final rel = key.substring(prefix.length);
if (rel.isEmpty) continue;
final data = await rootBundle.load(key);
final out = File('${dir.path}/$rel');
await out.parent.create(recursive: true);
await out.writeAsBytes(data.buffer.asUint8List(
data.offsetInBytes, data.lengthInBytes));
}
return dir;
}
@override
void initState() {
super.initState();
_start();
}
Future<void> _start() async {
try {
_extractDir = await _extractAssets();
final server = await HttpServer.bind(InternetAddress.loopbackIPv4, 0);
_server = server;
_port = server.port;
server.listen(_handleRequest);
if (mounted) setState(() {});
} catch (e) {
if (mounted) setState(() => _error = e.toString());
}
}
/// 只服务课件目录内的文件,路径做规范化防止越界。
Future<void> _handleRequest(HttpRequest req) async {
var path = Uri.decodeFull(req.uri.path);
if (path == '/' || path.isEmpty) path = '/index.html';
// 去掉开头斜杠,拼到资源根目录
final rel = path.replaceFirst(RegExp(r'^/+'), '');
final normalized = _normalize(rel);
final file = File('${_extractDir?.path ?? "."}/$normalized');
try {
if (!await file.exists()) {
req.response.statusCode = HttpStatus.notFound;
req.response.write('404 $rel');
await req.response.close();
return;
}
final length = await file.length();
// _mimeOf 返回完整 MIME(含主/子类型);charset 由 HTML 的 meta 声明。
req.response.headers.contentType = ContentType.parse(_mimeOf(rel));
req.response.headers.set('Accept-Ranges', 'bytes');
// 视频拖动依赖 HTTP Range;解析 "bytes=start-end" 返回 206。
final range = req.headers.value('range');
if (range != null && range.startsWith('bytes=')) {
final span = range.substring(6).split('-');
var start = int.tryParse(span.first) ?? 0;
var end = span.length > 1 ? int.tryParse(span.last) : null;
if (start < 0) start = 0;
if (start >= length) {
req.response.statusCode = HttpStatus.requestedRangeNotSatisfiable;
req.response.headers.set('Content-Range', 'bytes */$length');
await req.response.close();
return;
}
end ??= length - 1;
if (end >= length) end = length - 1;
if (end < start) end = start;
req.response.statusCode = HttpStatus.partialContent;
req.response.headers.set('Content-Range', 'bytes $start-$end/$length');
req.response.headers.set('Content-Length', '${end - start + 1}');
await req.response.addStream(
file.openRead(start, end + 1).cast<List<int>>());
await req.response.close();
return;
}
req.response.headers.set('Content-Length', '$length');
await req.response.addStream(file.openRead().cast<List<int>>());
await req.response.close();
} catch (e) {
req.response.statusCode = HttpStatus.internalServerError;
await req.response.close();
}
}
/// 折叠 .. 与 .,防止 ../ 越界读取其他文件。
static String _normalize(String path) {
final parts = <String>[];
for (final seg in path.split('/')) {
if (seg.isEmpty || seg == '.') continue;
if (seg == '..') {
if (parts.isNotEmpty) parts.removeLast();
continue;
}
parts.add(seg);
}
return parts.join('/');
}
static String _mimeOf(String path) {
final ext = path.split('.').last.toLowerCase();
switch (ext) {
case 'html':
case 'htm':
return 'text/html';
case 'css':
return 'text/css';
case 'js':
return 'text/javascript';
case 'json':
return 'application/json';
case 'png':
return 'image/png';
case 'jpg':
case 'jpeg':
return 'image/jpeg';
case 'gif':
return 'image/gif';
case 'svg':
return 'image/svg+xml';
case 'mp4':
return 'video/mp4';
case 'webm':
return 'video/webm';
case 'ico':
return 'image/x-icon';
default:
return 'application/octet-stream';
}
}
Future<void> _reload() async {
if (_port == null) return;
await _controller?.loadUrl(
urlRequest: URLRequest(
url: WebUri('http://127.0.0.1:$_port/index.html'),
),
);
}
@override
void dispose() {
unawaited(() async {
await _server?.close();
try {
await _extractDir?.delete(recursive: true);
} catch (_) {
// 临时目录清理失败无需影响页面销毁。
}
}());
super.dispose();
}
@override
Widget build(BuildContext context) {
super.build(context);
return Column(
crossAxisAlignment: CrossAxisAlignment.stretch,
children: <Widget>[
_toolbar(),
Expanded(child: _body()),
],
);
}
Widget _toolbar() {
return Container(
padding: const EdgeInsets.symmetric(horizontal: 20, vertical: 12),
decoration: BoxDecoration(
color: GcColors.surface,
border: Border(bottom: BorderSide(color: GcColors.line)),
),
child: Row(
children: <Widget>[
const Icon(Icons.terrain_rounded, size: 20),
const SizedBox(width: 10),
const Text(
'等高线地形 · 五大典型地貌判读',
style: TextStyle(fontSize: 15, fontWeight: FontWeight.w600),
),
const Spacer(),
IconButton(
tooltip: '刷新',
icon: const Icon(Icons.refresh_rounded, size: 18),
onPressed: _reload,
),
IconButton(
tooltip: '全屏',
icon: const Icon(Icons.fullscreen_rounded, size: 18),
onPressed: () => _controller?.evaluateJavascript(
source: 'document.documentElement.requestFullscreen?.();',
),
),
],
),
);
}
Widget _body() {
if (_error != null) {
return Center(child: Text('课件加载失败:$_error'));
}
if (_port == null) {
return const Center(child: CircularProgressIndicator(strokeWidth: 2));
}
return _webview();
}
Widget _webview() {
return Stack(
children: <Widget>[
InAppWebView(
initialUrlRequest: URLRequest(
url: WebUri('http://127.0.0.1:$_port/index.html'),
),
initialSettings: InAppWebViewSettings(
javaScriptEnabled: true,
mediaPlaybackRequiresUserGesture: false,
allowsInlineMediaPlayback: true,
supportZoom: false,
clearCache: false,
// 本地可信内容,允许混合加载。
mixedContentMode: MixedContentMode.MIXED_CONTENT_ALWAYS_ALLOW,
),
onWebViewCreated: (controller) => _controller = controller,
onProgressChanged: (_, progress) {
if (mounted && progress < 100) {
setState(() => _progress = progress / 100);
}
},
onLoadStop: (_, __) {
if (mounted) setState(() => _progress = 1);
},
onReceivedError: (_, request, error) {
if (mounted) {
setState(() => _error = '${error.type} ${error.description}');
}
},
),
if (_progress < 1)
Positioned(
top: 0,
left: 0,
right: 0,
child: SizedBox(
height: 2,
child: LinearProgressIndicator(value: _progress),
),
),
],
);
}
}
-579
View File
@@ -1,579 +0,0 @@
import 'dart:async';
import 'package:flutter/material.dart';
import '../api_client.dart';
import '../controller.dart';
import '../i18n.dart';
import '../theme.dart';
// ---------------------------------------------------------------------------
// 下载页(从原 pages.dart 拆出,公开类名不变)
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
// 下载页
// ---------------------------------------------------------------------------
class DownloadPageView extends StatefulWidget {
const DownloadPageView({
super.key,
required this.controller,
this.initialSources,
this.initialIndex,
this.initialJobs,
});
final ShellController controller;
/// 预置数据(仅用于测试 / 截图,正常运行时为 null,由后端提供)。
final List<SourceInfo>? initialSources;
final SourceIndexInfo? initialIndex;
final List<JobInfo>? initialJobs;
@override
State<DownloadPageView> createState() => _DownloadPageViewState();
}
class _DownloadPageViewState extends State<DownloadPageView> {
List<SourceInfo> _sources = const <SourceInfo>[];
SourceIndexInfo? _index;
List<JobInfo> _jobs = const <JobInfo>[];
String? _selectedSourceId;
bool _loading = true;
String? _error;
Timer? _poll;
/// 页面是否可见(被切走后仍保活,但没必要继续请求后端)。
bool _visible = true;
/// 上一次轮询时是否有活跃任务,用来判断「刚刚全部结束」。
bool _hadActive = false;
@override
void initState() {
super.initState();
final presetSources = widget.initialSources;
if (presetSources != null) {
_sources = presetSources;
_index = widget.initialIndex;
_jobs = widget.initialJobs ?? const <JobInfo>[];
_selectedSourceId = presetSources.isEmpty ? null : presetSources.first.id;
_loading = false;
return;
}
_load();
_schedulePoll(const Duration(seconds: 2));
}
@override
void didChangeDependencies() {
super.didChangeDependencies();
// TickerMode 由外壳的 Offstage 控制:切到别的页时变 false。
_visible = TickerMode.of(context);
}
@override
void dispose() {
_poll?.cancel();
super.dispose();
}
/// 单次 Timer 链:有活跃任务时 1 秒一次,空闲时降到 5 秒,不可见时 10 秒。
///
/// 以前是 `Timer.periodic(1s)` 且永不停止 —— 只要进过下载页,之后每秒都
/// 在请求 `/api/download/jobs`,哪怕没有任何任务、页面也早就切走了。
void _schedulePoll(Duration delay) {
_poll?.cancel();
_poll = Timer(delay, _pollOnce);
}
Future<void> _pollOnce() async {
if (!mounted) return;
if (!_visible) {
_schedulePoll(const Duration(seconds: 10));
return;
}
_hadActive = _jobs.any((job) => job.isActive);
await _refreshJobs();
if (!mounted) return;
final active = _jobs.any((job) => job.isActive);
// 活跃 → 空闲:这一轮里下载结束了,首页的模型列表已经过期。
if (_hadActive && !active) widget.controller.modelsChanged();
_hadActive = active;
_schedulePoll(Duration(seconds: active ? 1 : 5));
}
Future<void> _load() async {
setState(() {
_loading = true;
_error = null;
});
try {
final sources = await widget.controller.api.sources();
final preferred = sources.where((s) => s.enabled).toList();
final selected = _selectedSourceId ??
(preferred.isNotEmpty
? preferred.first.id
: (sources.isNotEmpty ? sources.first.id : ''));
final index = selected.isEmpty
? null
: await widget.controller.api.remoteModels(sourceId: selected);
if (!mounted) return;
setState(() {
_sources = sources;
_selectedSourceId = selected;
_index = index;
_loading = false;
});
await _refreshJobs();
} catch (error) {
if (!mounted) return;
setState(() {
_error = error.toString();
_loading = false;
});
}
}
Future<void> _refreshJobs() async {
try {
final jobs = await widget.controller.api.jobs();
if (!mounted) return;
setState(() => _jobs = jobs);
} catch (_) {
// 轮询失败不打扰用户,下一次再试
}
}
Future<void> _selectSource(String id) async {
setState(() {
_selectedSourceId = id;
_loading = true;
_error = null;
});
try {
final index = await widget.controller.api.remoteModels(sourceId: id);
if (!mounted) return;
setState(() {
_index = index;
_loading = false;
});
} catch (error) {
if (!mounted) return;
setState(() {
_error = error.toString();
_loading = false;
});
}
}
Future<void> _download(RemoteModelInfo model) async {
final sourceId = _selectedSourceId;
if (sourceId == null) return;
try {
await widget.controller.api.startDownload(sourceId, model.id);
await _refreshJobs();
} catch (error) {
if (!mounted) return;
setState(() => _error = error.toString());
}
}
Future<void> _jobAction(
Future<JobInfo> Function(String id) action, String id) async {
try {
await action(id);
await _refreshJobs();
} catch (error) {
if (!mounted) return;
setState(() => _error = error.toString());
}
}
@override
Widget build(BuildContext context) {
return Padding(
padding: const EdgeInsets.fromLTRB(
GcSpace.xxl, GcSpace.xxl, GcSpace.xxl, GcSpace.xl),
child: Row(
crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
SizedBox(width: 268, child: _sourcePanel()),
const SizedBox(width: GcSpace.xl),
Expanded(child: _modelPanel()),
],
),
);
}
Widget _sourcePanel() {
return GcCard(
padding: const EdgeInsets.all(GcSpace.lg),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
mainAxisSize: MainAxisSize.min,
children: <Widget>[
GcSectionTitle(T('dl.sources')),
const SizedBox(height: GcSpace.xs + 2),
GcHint(T('dl.subtitle')),
const SizedBox(height: GcSpace.md),
for (final source in _sources)
Padding(
padding: const EdgeInsets.only(bottom: GcSpace.xs + 2),
child: _sourceTile(source),
),
const SizedBox(height: GcSpace.sm),
SizedBox(
width: double.infinity,
child: OutlinedButton.icon(
onPressed: _load,
icon: const Icon(Icons.refresh_rounded, size: 18),
label: Text(T('dl.refresh')),
),
),
],
),
);
}
Widget _sourceTile(SourceInfo source) {
final selected = source.id == _selectedSourceId;
return Material(
color: selected ? GcColors.accentSoft : Colors.transparent,
borderRadius: BorderRadius.circular(GcRadius.control),
child: InkWell(
borderRadius: BorderRadius.circular(GcRadius.control),
hoverColor: GcColors.surfaceAlt,
onTap: () => _selectSource(source.id),
child: Container(
padding: const EdgeInsets.symmetric(
horizontal: GcSpace.md,
vertical: GcSpace.md - 2,
),
decoration: BoxDecoration(
borderRadius: BorderRadius.circular(GcRadius.control),
border: Border.all(
color: selected
? GcColors.accent.withOpacity(0.45)
: Colors.transparent,
),
),
child: Row(
children: <Widget>[
Icon(
selected
? Icons.radio_button_checked_rounded
: Icons.radio_button_unchecked_rounded,
size: 16,
color: selected ? GcColors.accent : GcColors.ghost,
),
const SizedBox(width: GcSpace.sm + 2),
Expanded(
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
mainAxisSize: MainAxisSize.min,
children: <Widget>[
Text(
source.name,
maxLines: 1,
overflow: TextOverflow.ellipsis,
style: TextStyle(
fontSize: 13,
height: 1.35,
fontWeight: FontWeight.w600,
color: selected ? GcColors.accent : GcColors.ink,
),
),
const SizedBox(height: 1),
Text(
source.host,
maxLines: 1,
overflow: TextOverflow.ellipsis,
style: TextStyle(
fontSize: 11.5,
height: 1.35,
color: GcColors.faint,
),
),
],
),
),
if (!source.enabled) const GcPill('off', subtle: true),
],
),
),
),
);
}
Widget _modelPanel() {
final models = _index?.models ?? const <RemoteModelInfo>[];
return Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
GcPageHeader(
title: T('dl.available'),
subtitle: _index == null
? null
: (_index!.fromCache
? '${T('dl.ready', <Object?>[
models.length
])} · ${T('dl.fromCache')}'
: T('dl.ready', <Object?>[models.length])),
trailing: IconButton(
tooltip: T('common.refresh'),
onPressed: _load,
icon: const Icon(Icons.refresh_rounded, size: 18),
),
),
const SizedBox(height: GcSpace.lg),
Expanded(
child: ListView(
padding: const EdgeInsets.only(bottom: GcSpace.sm),
children: <Widget>[
if (_loading)
const Padding(
padding: EdgeInsets.symmetric(vertical: 48),
child: Center(
child: SizedBox(
width: 22,
height: 22,
child: CircularProgressIndicator(strokeWidth: 2),
),
),
)
else if (_error != null)
GcMessage(
title: T('common.error'),
message: _error,
icon: Icons.cloud_off_rounded,
color: GcColors.danger,
action: OutlinedButton(
onPressed: _load,
child: Text(T('common.retry')),
),
)
else if (models.isEmpty)
GcMessage(
title: T('dl.empty'),
message: T('dl.emptyHint'),
icon: Icons.inbox_rounded,
)
else
for (final model in models)
Padding(
padding: const EdgeInsets.only(bottom: GcSpace.md),
child: _remoteRow(model),
),
const SizedBox(height: GcSpace.sm),
_jobsPanel(),
],
),
),
],
);
}
Widget _remoteRow(RemoteModelInfo model) {
return GcCard(
padding: const EdgeInsets.fromLTRB(
GcSpace.lg,
GcSpace.md + 2,
GcSpace.lg,
GcSpace.md + 2,
),
child: Row(
children: <Widget>[
Expanded(
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
Row(
children: <Widget>[
Flexible(
child: Text(
model.name,
maxLines: 1,
overflow: TextOverflow.ellipsis,
style: TextStyle(
fontSize: 14,
height: 1.35,
fontWeight: FontWeight.w600,
color: GcColors.ink,
),
),
),
const SizedBox(width: GcSpace.sm),
Text(
'v${model.version} · ${model.sizeText}',
style: TextStyle(
fontSize: 12,
height: 1.35,
color: GcColors.faint,
),
),
if (model.installed) ...<Widget>[
const SizedBox(width: GcSpace.sm),
GcPill(T('dl.installed'), color: GcColors.ok),
],
],
),
const SizedBox(height: GcSpace.xs + 1),
Text(
model.description,
maxLines: 2,
overflow: TextOverflow.ellipsis,
style: TextStyle(
fontSize: 12.5,
height: 1.5,
color: GcColors.muted,
),
),
],
),
),
const SizedBox(width: GcSpace.lg),
if (model.installed)
OutlinedButton(
onPressed: () => _download(model),
child: Text(T('dl.reinstall')),
)
else
FilledButton(
onPressed: () => _download(model),
child: Text(T('dl.download')),
),
],
),
);
}
Widget _jobsPanel() {
return GcCard(
padding: const EdgeInsets.all(GcSpace.lg),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
GcSectionTitle(
T('dl.background'),
trailing: TextButton(
onPressed: () async {
try {
await widget.controller.api.clearFinished();
await _refreshJobs();
} catch (_) {
// 忽略
}
},
child: Text(T('dl.clearDone')),
),
),
const SizedBox(height: GcSpace.md),
if (_jobs.isEmpty)
GcHint(T('dl.bgEmpty'))
else
for (final job in _jobs)
Padding(
padding: const EdgeInsets.only(bottom: GcSpace.md),
child: _jobRow(job),
),
],
),
);
}
Widget _jobRow(JobInfo job) {
return Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
Row(
children: <Widget>[
Expanded(
child: Text(
'${job.name} v${job.version}',
maxLines: 1,
overflow: TextOverflow.ellipsis,
style: TextStyle(
fontSize: 13,
height: 1.35,
fontWeight: FontWeight.w600,
color: GcColors.ink,
),
),
),
GcPill(
_stateLabel(job.state),
color: job.state == 'Failed'
? GcColors.danger
: job.state == 'Completed'
? GcColors.ok
: GcColors.accent,
),
const SizedBox(width: GcSpace.sm),
if (job.isActive)
TextButton(
onPressed: () =>
_jobAction(widget.controller.api.cancelJob, job.id),
child: Text(T('dl.cancel')),
)
else if (job.canRetry)
TextButton(
onPressed: () =>
_jobAction(widget.controller.api.retryJob, job.id),
child: Text(T('dl.retry')),
)
else
TextButton(
onPressed: () =>
_jobAction(widget.controller.api.removeJob, job.id),
child: Text(T('dl.removeTask')),
),
],
),
const SizedBox(height: GcSpace.sm - 2),
ClipRRect(
borderRadius: BorderRadius.circular(2),
child: LinearProgressIndicator(
value: job.progress.clamp(0, 1).toDouble(),
minHeight: 4,
backgroundColor: GcColors.surfaceAlt,
),
),
const SizedBox(height: GcSpace.xs + 1),
Text(
job.error ?? job.detailText,
style: TextStyle(
fontSize: 11.5,
height: 1.4,
color: GcColors.faint,
),
),
],
);
}
String _stateLabel(String state) {
switch (state) {
case 'Queued':
return T('dl.status.queued');
case 'Running':
case 'Downloading':
return T('dl.status.downloading');
case 'Completed':
return T('dl.status.done');
case 'Failed':
return T('dl.status.failed');
case 'Canceled':
return T('dl.status.canceled');
default:
return state;
}
}
}
-690
View File
@@ -1,690 +0,0 @@
import 'dart:async';
import 'package:flutter/material.dart';
import '../api_client.dart';
import '../controller.dart';
import '../i18n.dart';
import '../theme.dart';
// ---------------------------------------------------------------------------
// 首页:模型库(从原 pages.dart 拆出,公开类名不变)
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
// 首页:模型库
// ---------------------------------------------------------------------------
class HomePageView extends StatefulWidget {
const HomePageView({super.key, required this.controller, this.initialModels});
final ShellController controller;
/// 预置模型列表(仅用于测试 / 截图,正常运行时为 null,由后端提供)。
final List<ModelInfo>? initialModels;
@override
State<HomePageView> createState() => _HomePageViewState();
}
class _HomePageViewState extends State<HomePageView> {
List<ModelInfo> _models = const <ModelInfo>[];
bool _loading = true;
String? _error;
String? _notice;
int _lastRevision = 0;
@override
void initState() {
super.initState();
widget.controller.addListener(_onControllerChanged);
_lastRevision = widget.controller.modelsRevision;
final preset = widget.initialModels;
if (preset != null) {
_models = preset;
_loading = false;
} else {
_load();
}
}
@override
void dispose() {
widget.controller.removeListener(_onControllerChanged);
super.dispose();
}
/// 下载完成 / 删除模型后重新拉列表:页面被 Offstage 保活,不会自己重建。
void _onControllerChanged() {
if (!mounted) return;
final revision = widget.controller.modelsRevision;
if (revision == _lastRevision) return;
_lastRevision = revision;
if (widget.initialModels != null) return; // 截图 / 测试用的预置数据
_load();
}
Future<void> _load() async {
setState(() {
_loading = true;
_error = null;
});
try {
final models = await widget.controller.api.models();
if (!mounted) return;
setState(() {
_models = models;
_loading = false;
});
} catch (error) {
if (!mounted) return;
setState(() {
_error = error.toString();
_loading = false;
});
}
}
Future<void> _launch(ModelInfo model) async {
setState(() => _notice = null);
try {
final result = await widget.controller.api.launchModel(model.id);
if (!mounted) return;
setState(() => _notice = result.message);
} catch (error) {
if (!mounted) return;
setState(() => _notice = error.toString());
}
}
Future<void> _delete(ModelInfo model) async {
final confirmed = await showDialog<bool>(
context: context,
builder: (context) => AlertDialog(
backgroundColor: GcColors.surface,
title: Text(T('common.confirmTitle')),
content: Text(T('home.deleteConfirm', <Object?>[model.name])),
actions: <Widget>[
TextButton(
onPressed: () => Navigator.of(context).pop(false),
child: Text(T('common.cancel')),
),
FilledButton(
onPressed: () => Navigator.of(context).pop(true),
child: Text(T('common.delete')),
),
],
),
);
if (confirmed != true) return;
try {
await widget.controller.api.deleteModel(model.id);
await _load();
} catch (error) {
if (!mounted) return;
setState(() => _notice = error.toString());
}
}
Future<void> _openFolder(String path) async {
try {
await widget.controller.api.openFolder(path);
} catch (error) {
if (!mounted) return;
setState(() => _notice = error.toString());
}
}
@override
Widget build(BuildContext context) {
final settings = widget.controller.settings;
return RefreshIndicator(
onRefresh: _load,
color: GcColors.accent,
backgroundColor: GcColors.surface,
child: ListView(
physics: const AlwaysScrollableScrollPhysics(),
padding: const EdgeInsets.fromLTRB(
GcSpace.xxl, GcSpace.xxl, GcSpace.xxl, GcSpace.xxxl),
children: <Widget>[
_hero(settings),
const SizedBox(height: GcSpace.xxl),
_sectionHeader(),
if (_notice != null) ...<Widget>[
const SizedBox(height: GcSpace.md),
GcMessage(
title: _notice!,
icon: Icons.info_outline_rounded,
color: GcColors.warn,
),
],
const SizedBox(height: GcSpace.lg),
if (_loading)
const Padding(
padding: EdgeInsets.symmetric(vertical: 48),
child: Center(
child: SizedBox(
width: 22,
height: 22,
child: CircularProgressIndicator(strokeWidth: 2),
),
),
)
else if (_error != null)
GcMessage(
title: T('common.error'),
message: _error,
icon: Icons.cloud_off_rounded,
color: GcColors.danger,
action: OutlinedButton(
onPressed: _load,
child: Text(T('common.retry')),
),
)
else if (_models.isEmpty)
_emptyState()
else
LayoutBuilder(
builder: (context, constraints) {
const spacing = GcSpace.lg;
final columns =
(constraints.maxWidth / 320).floor().clamp(1, 4);
final cardWidth =
(constraints.maxWidth - spacing * (columns - 1)) / columns;
return Wrap(
spacing: spacing,
runSpacing: spacing,
children: <Widget>[
for (final model in _models)
SizedBox(
width: cardWidth,
child: _ModelCard(
model: model,
previewUrl: widget.controller.api.previewUrl(model),
onLaunch: () => _launch(model),
onOpenFolder: () => _openFolder(model.directory),
onDelete: () => _delete(model),
),
),
],
);
},
),
],
),
);
}
/// 顶部横幅:产品定位 + 主操作 + 关键指标。
///
/// 不用渐变:深色主题下的低对比渐变会让整块区域发灰,看起来就是「糊」。
Widget _hero(SettingsInfo? settings) {
final enabledSources =
settings?.sources.where((s) => s.enabled).length ?? 0;
return GcCard(
padding: const EdgeInsets.all(GcSpace.xxl + 2),
child: Row(
crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
Expanded(
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
Text(
'MODEL LIBRARY',
style: TextStyle(
fontSize: 11,
height: 1.2,
letterSpacing: 1.4,
fontWeight: FontWeight.w600,
color: GcColors.accent,
),
),
const SizedBox(height: GcSpace.md),
Text(
T('home.title'),
style: TextStyle(
fontSize: 26,
height: 1.25,
fontWeight: FontWeight.w600,
letterSpacing: -0.2,
color: GcColors.ink,
),
),
const SizedBox(height: GcSpace.sm),
ConstrainedBox(
constraints: const BoxConstraints(maxWidth: 460),
child: Text(
T('home.subtitle'),
style: TextStyle(
fontSize: 13,
height: 1.65,
color: GcColors.muted,
),
),
),
const SizedBox(height: GcSpace.xl),
Row(
children: <Widget>[
FilledButton.icon(
onPressed:
_models.isEmpty ? null : () => _launch(_models.first),
icon: const Icon(Icons.play_arrow_rounded, size: 18),
label: Text(T('home.launch')),
),
const SizedBox(width: GcSpace.md),
OutlinedButton(
onPressed: () => widget.controller.goTo(2),
child: Text(T('home.download')),
),
const SizedBox(width: GcSpace.xs),
TextButton(
onPressed: () => widget.controller.goTo(3),
child: Text(T('home.settings')),
),
],
),
const SizedBox(height: GcSpace.md),
Text(
T('home.launchHint'),
style: TextStyle(
fontSize: 12,
height: 1.55,
color: GcColors.faint,
),
),
],
),
),
const SizedBox(width: GcSpace.xxl),
Container(
padding: const EdgeInsets.symmetric(
horizontal: GcSpace.xl,
vertical: GcSpace.lg,
),
decoration: BoxDecoration(
color: GcColors.surfaceAlt,
borderRadius: BorderRadius.circular(GcRadius.control),
border: Border.all(color: GcColors.line),
),
child: Row(
mainAxisSize: MainAxisSize.min,
children: <Widget>[
GcMetric(
value: '${_models.length}',
label: T('home.stats.models'),
),
_metricDivider(),
GcMetric(
value: '$enabledSources',
label: T('home.stats.sources'),
),
_metricDivider(),
GcMetric(
value: '${settings?.memoryBudgetMb ?? 0}',
label: T('home.stats.memory'),
),
],
),
),
],
),
);
}
Widget _metricDivider() {
return Container(
width: 1,
height: 34,
margin: const EdgeInsets.symmetric(horizontal: GcSpace.xl),
color: GcColors.line,
);
}
Widget _sectionHeader() {
return Row(
children: <Widget>[
Text(
T('home.installed'),
style: TextStyle(
fontSize: 16,
height: 1.4,
fontWeight: FontWeight.w600,
color: GcColors.ink,
),
),
const SizedBox(width: GcSpace.sm),
GcPill(T('home.count', <Object?>[_models.length]), subtle: true),
const Spacer(),
IconButton(
tooltip: T('common.refresh'),
onPressed: _load,
icon: const Icon(Icons.refresh_rounded, size: 18),
),
],
);
}
Widget _emptyState() {
return GcCard(
padding: const EdgeInsets.symmetric(
horizontal: GcSpace.xxxl,
vertical: 40,
),
child: Column(
children: <Widget>[
Container(
width: 52,
height: 52,
alignment: Alignment.center,
decoration: BoxDecoration(
color: GcColors.accentSoft,
borderRadius: BorderRadius.circular(GcRadius.panel),
),
child: Icon(
Icons.travel_explore_rounded,
size: 26,
color: GcColors.accent,
),
),
const SizedBox(height: GcSpace.lg),
Text(
T('home.empty'),
style: TextStyle(
fontSize: 16,
height: 1.4,
fontWeight: FontWeight.w600,
color: GcColors.ink,
),
),
const SizedBox(height: GcSpace.sm),
ConstrainedBox(
constraints: const BoxConstraints(maxWidth: 420),
child: Text(
T('home.emptyHint'),
textAlign: TextAlign.center,
style: TextStyle(
fontSize: 12.5,
height: 1.7,
color: GcColors.muted,
),
),
),
const SizedBox(height: GcSpace.xl),
FilledButton(
onPressed: () => widget.controller.goTo(2),
child: Text(T('home.emptyAction')),
),
],
),
);
}
}
class _ModelCard extends StatefulWidget {
const _ModelCard({
required this.model,
required this.previewUrl,
required this.onLaunch,
required this.onOpenFolder,
required this.onDelete,
});
final ModelInfo model;
final String previewUrl;
final VoidCallback onLaunch;
final VoidCallback onOpenFolder;
final VoidCallback onDelete;
@override
State<_ModelCard> createState() => _ModelCardState();
}
class _ModelCardState extends State<_ModelCard> {
bool _hover = false;
@override
Widget build(BuildContext context) {
final model = widget.model;
return MouseRegion(
onEnter: (_) => setState(() => _hover = true),
onExit: (_) => setState(() => _hover = false),
cursor: SystemMouseCursors.click,
child: GcCard(
padding: EdgeInsets.zero,
clip: true,
borderColor: _hover ? GcColors.lineStrong : GcColors.line,
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
_cover(model),
Padding(
padding: const EdgeInsets.fromLTRB(
GcSpace.lg,
GcSpace.md + 2,
GcSpace.lg,
GcSpace.md,
),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
Row(
children: <Widget>[
Expanded(
child: Text(
model.name,
maxLines: 1,
overflow: TextOverflow.ellipsis,
style: TextStyle(
fontSize: 14.5,
height: 1.35,
fontWeight: FontWeight.w600,
color: GcColors.ink,
),
),
),
const SizedBox(width: GcSpace.sm),
Text(
model.sizeText,
style: TextStyle(
fontSize: 12,
height: 1.35,
color: GcColors.faint,
),
),
],
),
const SizedBox(height: GcSpace.sm - 2),
SizedBox(
height: 36,
child: Text(
model.description.isEmpty
? T('home.noDescription')
: model.description,
maxLines: 2,
overflow: TextOverflow.ellipsis,
style: TextStyle(
fontSize: 12.5,
height: 1.45,
color: model.description.isEmpty
? GcColors.faint
: GcColors.muted,
),
),
),
if (model.tags.isNotEmpty) ...<Widget>[
const SizedBox(height: GcSpace.sm + 2),
SizedBox(
height: 20,
child: Wrap(
spacing: 6,
runSpacing: 6,
children: <Widget>[
for (final tag in model.tags.take(3))
GcPill(tag, subtle: true),
],
),
),
],
const SizedBox(height: GcSpace.md + 2),
Row(
children: <Widget>[
FilledButton.icon(
onPressed: widget.onLaunch,
icon: const Icon(Icons.play_arrow_rounded, size: 18),
label: Text(T('home.launch')),
),
const Spacer(),
IconButton(
tooltip: T('home.open'),
onPressed: widget.onOpenFolder,
icon: const Icon(Icons.folder_open_rounded, size: 18),
),
IconButton(
tooltip: T('home.delete'),
onPressed: widget.onDelete,
icon:
const Icon(Icons.delete_outline_rounded, size: 18),
),
],
),
],
),
),
],
),
),
);
}
/// 封面:按卡片宽度和屏幕像素比解码,避免被放大后发虚。
Widget _cover(ModelInfo model) {
final dpr = MediaQuery.devicePixelRatioOf(context);
final decodeWidth =
(MediaQuery.sizeOf(context).width * dpr).clamp(320, 900).round();
return SizedBox(
height: 156,
width: double.infinity,
child: Stack(
fit: StackFit.expand,
children: <Widget>[
_PreviewFallback(model: model),
if (model.hasPreview)
Image.network(
widget.previewUrl,
fit: BoxFit.cover,
cacheWidth: decodeWidth,
filterQuality: FilterQuality.medium,
gaplessPlayback: true,
errorBuilder: (context, error, stack) => const SizedBox.shrink(),
),
DecoratedBox(
decoration: BoxDecoration(
// 只用「透明 → 深色」的遮罩,别用 alphaBlend:叠加不透明底色
// 会把整张封面盖平,占位字母也跟着消失。
gradient: LinearGradient(
begin: Alignment.topCenter,
end: Alignment.bottomCenter,
colors: <Color>[
GcColors.appBg.withOpacity(0.0),
GcColors.appBg.withOpacity(0.32),
GcColors.appBg.withOpacity(0.88),
],
stops: const <double>[0.42, 0.72, 1.0],
),
),
),
Positioned(
left: GcSpace.md,
right: GcSpace.sm,
bottom: GcSpace.sm,
child: Row(
children: <Widget>[
if (model.version.isNotEmpty)
GcPill('v${model.version}', color: GcColors.accent),
if (model.author.isNotEmpty) ...<Widget>[
const SizedBox(width: GcSpace.sm),
Flexible(
child: Text(
model.author,
maxLines: 1,
overflow: TextOverflow.ellipsis,
style: TextStyle(
fontSize: 11.5,
height: 1.3,
color: GcColors.muted,
),
),
),
],
const Spacer(),
AnimatedOpacity(
opacity: _hover ? 1 : 0,
duration: const Duration(milliseconds: 140),
child: Container(
width: 26,
height: 26,
decoration: BoxDecoration(
color: GcColors.accentFill,
shape: BoxShape.circle,
),
child: Icon(
Icons.play_arrow_rounded,
size: 18,
color: GcColors.onAccent,
),
),
),
],
),
),
],
),
);
}
}
/// 没有封面时的占位:型号首字 + 淡淡的网格感,比一个大「◎」更像封面。
class _PreviewFallback extends StatelessWidget {
const _PreviewFallback({this.model});
final ModelInfo? model;
@override
Widget build(BuildContext context) {
final label = (model?.name ?? '').characters.isEmpty
? '◎'
: model!.name.characters.first;
return DecoratedBox(
decoration: BoxDecoration(
gradient: LinearGradient(
begin: Alignment.topLeft,
end: Alignment.bottomRight,
colors: <Color>[
Color.alphaBlend(
GcColors.accent.withOpacity(0.22),
GcColors.surfaceAlt,
),
GcColors.surfaceAlt,
],
),
),
child: Center(
child: Text(
label,
style: TextStyle(
fontSize: 46,
height: 1.0,
fontWeight: FontWeight.w600,
color: Color.alphaBlend(
GcColors.accent.withOpacity(0.55),
GcColors.surfaceAlt,
),
),
),
),
);
}
}
-699
View File
@@ -1,699 +0,0 @@
import 'dart:async';
import 'package:flutter/material.dart';
import '../api_client.dart';
import '../controller.dart';
import '../i18n.dart';
import '../theme.dart';
// ---------------------------------------------------------------------------
// 设置页(从原 pages.dart 拆出,公开类名不变)
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
// 设置页
// ---------------------------------------------------------------------------
class SettingsPageView extends StatefulWidget {
const SettingsPageView({super.key, required this.controller});
final ShellController controller;
@override
State<SettingsPageView> createState() => _SettingsPageViewState();
}
class _SettingsPageViewState extends State<SettingsPageView> {
double _memory = 2048;
bool _memoryAuto = true;
int _fps = 120;
bool _autoUpdate = true;
String _language = 'auto';
ThemeMode _themeMode = ThemeMode.dark;
/// 上一次同步所用的设置对象。以前用的是 `bool _synced` —— 只同步一次,
/// 之后外部(更新状态条、其它页面)改了设置,本页仍显示旧值。
SettingsInfo? _syncedFrom;
String? _status;
@override
void initState() {
super.initState();
widget.controller.reloadSettings();
}
void _syncFrom(SettingsInfo settings) {
if (identical(_syncedFrom, settings)) return;
_syncedFrom = settings;
_memory = settings.memoryMb.toDouble();
_memoryAuto = settings.memoryAuto;
_fps = settings.renderFps;
_autoUpdate = settings.autoUpdateOnStartup;
_language = settings.language;
_themeMode = GcPalette.parseMode(settings.theme);
}
@override
Widget build(BuildContext context) {
final settings = widget.controller.settings;
if (settings == null) {
return const Center(
child: SizedBox(
width: 22,
height: 22,
child: CircularProgressIndicator(strokeWidth: 2),
),
);
}
_syncFrom(settings);
return LayoutBuilder(
builder: (context, constraints) {
final twoColumns = constraints.maxWidth >= 960;
final cards = <Widget>[
_generalCard(settings),
_appearanceCard(settings),
_memoryCard(settings),
_sourcesCard(settings),
_storageCard(settings),
_updateCard(settings),
_backendCard(settings),
];
Widget column(List<Widget> items) => Column(
crossAxisAlignment: CrossAxisAlignment.stretch,
children: <Widget>[
for (var i = 0; i < items.length; i++) ...<Widget>[
if (i > 0) const SizedBox(height: GcSpace.lg),
items[i],
],
],
);
final left = <Widget>[];
final right = <Widget>[];
for (var i = 0; i < cards.length; i++) {
if (twoColumns && i.isOdd) {
right.add(cards[i]);
} else {
left.add(cards[i]);
}
}
return SingleChildScrollView(
padding: const EdgeInsets.fromLTRB(
GcSpace.xxl,
GcSpace.xxl,
GcSpace.xxl,
GcSpace.xxxl,
),
child: Column(
crossAxisAlignment: CrossAxisAlignment.stretch,
children: <Widget>[
GcPageHeader(
title: T('set.title'),
subtitle: T('set.subtitle'),
trailing: _status == null
? null
: GcPill(
_status!,
color: GcColors.ok,
icon: Icons.check_rounded,
),
),
const SizedBox(height: GcSpace.xxl),
if (twoColumns)
Row(
crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
Expanded(child: column(left)),
const SizedBox(width: GcSpace.lg),
Expanded(child: column(right)),
],
)
else
column(cards),
],
),
);
},
);
}
Widget _label(String text) {
return Text(
text,
style: TextStyle(fontSize: 13, height: 1.5, color: GcColors.muted),
);
}
Widget _cardRow(String label, Widget control) {
return Padding(
padding: const EdgeInsets.symmetric(vertical: GcSpace.sm),
child: Row(
children: <Widget>[
SizedBox(width: 124, child: _label(label)),
Expanded(child: control),
],
),
);
}
Widget _generalCard(SettingsInfo settings) {
return GcCard(
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
GcSectionTitle(T('set.general')),
const SizedBox(height: GcSpace.lg),
_cardRow(
T('set.language'),
Align(
alignment: Alignment.centerLeft,
child: DropdownButton<String>(
value: _language,
dropdownColor: GcColors.surfaceAlt,
underline: const SizedBox.shrink(),
borderRadius: BorderRadius.circular(GcRadius.control),
// 从主题样式派生,才能继承字体族(自建 TextStyle 会丢掉
// fontFamily,中文就回退成系统兜底字体)。
style: Theme.of(context).textTheme.bodyLarge!.copyWith(
fontSize: 13,
height: 1.4,
fontWeight: FontWeight.w400,
color: GcColors.ink,
),
items: <DropdownMenuItem<String>>[
DropdownMenuItem<String>(
value: 'auto',
child: Text(T('set.language.auto')),
),
for (final language in settings.languages)
DropdownMenuItem<String>(
value: language.code,
child: Text(language.label),
),
],
onChanged: (value) async {
if (value == null) return;
setState(() => _language = value);
await widget.controller
.saveSettings(SettingsPatch(language: value));
},
),
),
),
_cardRow(
T('set.fps'),
Row(
children: <Widget>[
Expanded(
child: Slider(
value: _fps.toDouble(),
min: 24,
max: 120,
divisions: 4,
label: '$_fps',
onChanged: (value) => setState(() => _fps = value.round()),
onChangeEnd: (value) async {
await widget.controller.saveSettings(
SettingsPatch(renderFps: value.round()));
if (mounted) {
setState(() => _status = T('common.applied'));
}
},
),
),
SizedBox(
width: 48,
child: Text(
'$_fps',
textAlign: TextAlign.end,
style: TextStyle(
fontSize: 13,
height: 1.4,
fontWeight: FontWeight.w600,
color: GcColors.ink,
),
),
),
],
),
),
GcHint(T('set.fps.desc')),
],
),
);
}
Widget _appearanceCard(SettingsInfo settings) {
final current =
GcPalette.parseHex(settings.accentColor) ?? GcPalette.defaultAccent;
return GcCard(
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
GcSectionTitle(T('set.appearance')),
const SizedBox(height: GcSpace.md),
GcHint(T('set.theme.desc')),
const SizedBox(height: GcSpace.md),
SegmentedButton<ThemeMode>(
segments: <ButtonSegment<ThemeMode>>[
ButtonSegment<ThemeMode>(
value: ThemeMode.dark,
label: Text(T('set.theme.dark')),
icon: const Icon(Icons.dark_mode_outlined, size: 16),
),
ButtonSegment<ThemeMode>(
value: ThemeMode.light,
label: Text(T('set.theme.light')),
icon: const Icon(Icons.light_mode_outlined, size: 16),
),
ButtonSegment<ThemeMode>(
value: ThemeMode.system,
label: Text(T('set.theme.system')),
icon: const Icon(Icons.brightness_auto_outlined, size: 16),
),
],
selected: <ThemeMode>{_themeMode},
showSelectedIcon: false,
onSelectionChanged: (selection) async {
final mode = selection.first;
setState(() => _themeMode = mode);
GcPalette.mode.value = mode; // 立即预览
await widget.controller.saveSettings(
SettingsPatch(theme: GcPalette.modeToName(mode)));
if (mounted) setState(() => _status = T('common.applied'));
},
),
const SizedBox(height: GcSpace.xl),
GcHint(T('set.accent.desc')),
const SizedBox(height: GcSpace.md + 2),
Wrap(
spacing: GcSpace.sm + 2,
runSpacing: GcSpace.sm + 2,
children: <Widget>[
for (final color in GcPalette.presets)
_accentSwatch(color, current),
_customAccentChip(),
],
),
const SizedBox(height: GcSpace.md),
Text(
'${T('set.accent')}: ${GcPalette.toHex(current)}',
style: TextStyle(
fontSize: 11.5,
height: 1.4,
color: GcColors.faint,
),
),
],
),
);
}
Widget _accentSwatch(Color color, Color current) {
final selected = color.value == current.value;
return Tooltip(
message: GcPalette.toHex(color),
child: GestureDetector(
onTap: () => _applyAccent(GcPalette.toHex(color)),
child: Container(
width: 34,
height: 34,
decoration: BoxDecoration(
color: color,
borderRadius: BorderRadius.circular(GcRadius.control),
border: Border.all(
color: selected ? GcColors.ink : Colors.transparent,
width: 2,
),
),
child: selected
? Icon(
Icons.check_rounded,
size: 18,
color: color.computeLuminance() > 0.42
? const Color(0xFF0A1226)
: Colors.white,
)
: null,
),
),
);
}
Widget _customAccentChip() {
return MouseRegion(
cursor: SystemMouseCursors.click,
child: GestureDetector(
onTap: _pickCustomAccent,
child: Container(
height: 34,
padding: const EdgeInsets.symmetric(horizontal: GcSpace.md),
decoration: BoxDecoration(
color: GcColors.surfaceAlt,
borderRadius: BorderRadius.circular(GcRadius.control),
border: Border.all(color: GcColors.line),
),
child: Row(
mainAxisSize: MainAxisSize.min,
children: <Widget>[
Icon(Icons.colorize_rounded, size: 16, color: GcColors.faint),
const SizedBox(width: GcSpace.xs + 2),
Text(
T('set.accent.custom'),
style: TextStyle(
fontSize: 12,
height: 1.3,
color: GcColors.muted,
),
),
],
),
),
),
);
}
Future<void> _pickCustomAccent() async {
final controller = TextEditingController(
text: GcPalette.toHex(GcPalette.accent.value),
);
final hex = await showDialog<String>(
context: context,
builder: (context) => AlertDialog(
backgroundColor: GcColors.surface,
title: Text(T('set.accent.custom')),
content: TextField(
controller: controller,
autofocus: true,
style: Theme.of(context).textTheme.bodyLarge!.copyWith(fontSize: 13),
decoration: InputDecoration(
hintText: '#8FB6FF',
helperText: T('set.accent.hexHint'),
),
onSubmitted: (value) => Navigator.of(context).pop(value),
),
actions: <Widget>[
TextButton(
onPressed: () => Navigator.of(context).pop(),
child: Text(T('common.cancel')),
),
FilledButton(
onPressed: () => Navigator.of(context).pop(controller.text),
child: Text(T('common.confirm')),
),
],
),
);
controller.dispose();
if (hex != null) await _applyAccent(hex);
}
Future<void> _applyAccent(String hex) async {
final parsed = GcPalette.parseHex(hex);
if (parsed == null) {
if (mounted) setState(() => _status = T('set.accent.invalid'));
return;
}
final normalized = GcPalette.toHex(parsed);
GcPalette.apply(normalized); // 立即预览
await widget.controller
.saveSettings(SettingsPatch(accentColor: normalized));
if (mounted) setState(() => _status = T('common.applied'));
}
Widget _memoryCard(SettingsInfo settings) {
return GcCard(
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
GcSectionTitle(T('set.memory')),
const SizedBox(height: GcSpace.md),
GcHint(T('set.memory.desc')),
const SizedBox(height: GcSpace.lg),
Row(
children: <Widget>[
Switch(
value: _memoryAuto,
onChanged: (value) async {
setState(() => _memoryAuto = value);
await widget.controller
.saveSettings(SettingsPatch(memoryAuto: value));
},
),
const SizedBox(width: GcSpace.md),
Expanded(
child: Text(
T('set.memory.auto'),
style: TextStyle(
fontSize: 13,
height: 1.5,
color: GcColors.muted,
),
),
),
],
),
const SizedBox(height: GcSpace.xs),
Row(
children: <Widget>[
Expanded(
child: Slider(
value: _memory,
min: 512,
max: 16384,
divisions: 62,
label: '${_memory.round()} MB',
onChanged: _memoryAuto
? null
: (value) => setState(() => _memory = value),
onChangeEnd: (value) async {
await widget.controller
.saveSettings(SettingsPatch(memoryMb: value.round()));
if (mounted) setState(() => _status = T('common.applied'));
},
),
),
SizedBox(
width: 104,
child: Text(
'${_memory.round()} MB',
textAlign: TextAlign.end,
style: TextStyle(
fontSize: 13,
height: 1.4,
fontWeight: FontWeight.w600,
color: GcColors.ink,
),
),
),
],
),
const SizedBox(height: GcSpace.xs),
GcHint('${T('set.memory.current')}: ${settings.memoryUsageText}'),
const SizedBox(height: GcSpace.xs),
GcHint(T('set.memory.hint')),
],
),
);
}
Widget _sourcesCard(SettingsInfo settings) {
return GcCard(
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
GcSectionTitle(T('set.sources')),
const SizedBox(height: GcSpace.md),
GcHint(T('set.sources.desc')),
const SizedBox(height: GcSpace.md),
for (final source in settings.sources)
Padding(
padding: const EdgeInsets.only(bottom: GcSpace.md),
child: Row(
children: <Widget>[
Expanded(
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
mainAxisSize: MainAxisSize.min,
children: <Widget>[
Text(
source.name,
style: TextStyle(
fontSize: 13,
height: 1.4,
fontWeight: FontWeight.w600,
color: GcColors.ink,
),
),
const SizedBox(height: 1),
Text(
source.url,
maxLines: 1,
overflow: TextOverflow.ellipsis,
style: TextStyle(
fontSize: 11.5,
height: 1.4,
color: GcColors.faint,
),
),
],
),
),
const SizedBox(width: GcSpace.sm),
if (source.enabled)
GcPill(T('set.sourceEnabled'), color: GcColors.ok)
else
const GcPill('—', subtle: true),
],
),
),
],
),
);
}
Widget _storageCard(SettingsInfo settings) {
return GcCard(
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
GcSectionTitle(T('set.storage')),
const SizedBox(height: GcSpace.md),
GcFieldRow(
label: T('set.modelDir'),
value: settings.modelRoot,
selectable: true,
valueColor: GcColors.muted,
),
GcFieldRow(
label: T('set.dataDir'),
value: settings.dataRoot,
selectable: true,
valueColor: GcColors.muted,
),
const SizedBox(height: GcSpace.md),
Wrap(
spacing: GcSpace.sm + 2,
runSpacing: GcSpace.sm + 2,
children: <Widget>[
OutlinedButton(
onPressed: () async {
try {
await widget.controller.api.openFolder(settings.modelRoot);
} catch (error) {
if (mounted) setState(() => _status = error.toString());
}
},
child: Text(T('set.openFolder')),
),
OutlinedButton(
onPressed: () async {
await widget.controller.checkUpdate(force: true);
if (mounted) setState(() => _status = T('set.cacheCleared'));
},
child: Text(T('set.clearCache')),
),
],
),
],
),
);
}
Widget _updateCard(SettingsInfo settings) {
return GcCard(
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
GcSectionTitle(T('update.title')),
const SizedBox(height: GcSpace.md),
GcHint(T('set.checkUpdate.desc')),
const SizedBox(height: GcSpace.md),
Row(
children: <Widget>[
Switch(
value: _autoUpdate,
onChanged: (value) async {
setState(() => _autoUpdate = value);
await widget.controller
.saveSettings(SettingsPatch(autoUpdateOnStartup: value));
},
),
const SizedBox(width: GcSpace.md),
Expanded(
child: Text(
T('update.auto'),
style: TextStyle(
fontSize: 13,
height: 1.5,
color: GcColors.muted,
),
),
),
],
),
const SizedBox(height: GcSpace.sm),
GcFieldRow(
label: T('update.source'),
value: settings.updateRepository,
selectable: true,
valueColor: GcColors.muted,
),
const SizedBox(height: GcSpace.md),
FilledButton(
onPressed: () => widget.controller.checkUpdate(force: true),
child: Text(T('update.checkNow')),
),
],
),
);
}
Widget _backendCard(SettingsInfo settings) {
final health = widget.controller.health;
return GcCard(
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
GcSectionTitle(T('set.backend')),
const SizedBox(height: GcSpace.md),
GcHint(T('set.backend.desc')),
const SizedBox(height: GcSpace.md),
GcFieldRow(
label: 'API',
value: widget.controller.api.baseUrl,
selectable: true,
valueColor: GcColors.muted,
),
GcFieldRow(
label: T('set.version'),
value: settings.version,
valueColor: GcColors.muted,
),
GcFieldRow(
label: T('set.platform'),
value: settings.platform,
valueColor: GcColors.muted,
),
GcFieldRow(
label: T('set.backend.ui'),
value: health == null
? '—'
: health.uiAvailable
? T('set.backend.uiOk')
: '${T('set.backend.uiBad')}${health.uiError == null ? '' : ' · ${health.uiError}'}',
valueColor: health == null
? GcColors.muted
: health.uiAvailable
? GcColors.ok
: GcColors.danger,
),
],
),
);
}
}
-460
View File
@@ -1,460 +0,0 @@
import 'package:flutter/material.dart';
import 'controller.dart';
import 'i18n.dart';
import 'pages.dart';
import 'theme.dart';
/// 侧边栏导航项。
class _NavItem {
const _NavItem(this.icon, this.labelKey);
final IconData icon;
final String labelKey;
}
const List<_NavItem> _navItems = <_NavItem>[
_NavItem(Icons.dashboard_rounded, 'nav.home'),
_NavItem(Icons.terrain_rounded, 'nav.courseware'),
_NavItem(Icons.download_rounded, 'nav.download'),
_NavItem(Icons.tune_rounded, 'nav.settings'),
_NavItem(Icons.info_outline_rounded, 'nav.about'),
];
/// 桌面端滚动行为:去掉移动端的拉伸回弹和边缘光晕,滚轮更跟手。
class GcScrollBehavior extends MaterialScrollBehavior {
const GcScrollBehavior();
@override
Widget buildOverscrollIndicator(
BuildContext context,
Widget child,
ScrollableDetails details,
) {
return child;
}
@override
ScrollPhysics getScrollPhysics(BuildContext context) {
return const ClampingScrollPhysics(parent: AlwaysScrollableScrollPhysics());
}
}
/// 应用外壳:左侧导航 + 右侧内容 + 底部更新状态条。
class ShellPage extends StatefulWidget {
const ShellPage({super.key, required this.controller});
final ShellController controller;
@override
State<ShellPage> createState() => _ShellPageState();
}
class _ShellPageState extends State<ShellPage> {
/// 页面缓存:键为「索引:语言」。同一个页面只构建一次,切走时用
/// [Offstage] 保活(不参与布局/绘制),切回来无需重建、状态也不丢。
final Map<String, Widget> _pages = <String, Widget>{};
@override
void initState() {
super.initState();
widget.controller.bootstrap();
}
@override
Widget build(BuildContext context) {
return AnimatedBuilder(
animation: widget.controller,
builder: (context, _) {
final controller = widget.controller;
return Scaffold(
backgroundColor: GcColors.appBg,
body: Row(
children: <Widget>[
_Sidebar(controller: controller),
Container(width: 1, color: GcColors.line),
Expanded(
child: Column(
children: <Widget>[
Expanded(child: _content(controller)),
if (controller.updateBarVisible)
_UpdateBar(controller: controller),
],
),
),
],
),
);
},
);
}
Widget _content(ShellController controller) {
// 课件页是纯前端资源,不依赖后端:即使后端未就绪也可打开。
// 注意 _buildPage 内部对 index 1 返回课件页,这里单独放行它。
final courseware = controller.index == 1;
if (!courseware && !controller.backendReady) {
if (controller.loadError != null) {
return _BackendDown(controller: controller);
}
return const Center(
child: SizedBox(
width: 22,
height: 22,
child: CircularProgressIndicator(strokeWidth: 2),
),
);
}
// 只构建当前页;其余已访问页面保留在树上但处于 Offstage。
final key = '${controller.index}:${I18n.language.value}';
_pages.putIfAbsent(key, () => _buildPage(controller, controller.index));
final visibleKey = key;
return Stack(
children: <Widget>[
for (final entry in _pages.entries)
Offstage(
offstage: entry.key != visibleKey,
child: TickerMode(
enabled: entry.key == visibleKey,
child: entry.value,
),
),
],
);
}
Widget _buildPage(ShellController controller, int index) {
switch (index) {
case 1:
// 课件页自持有 WebView 状态,不需要 controller。
return const CoursewarePage();
case 2:
return DownloadPageView(controller: controller);
case 3:
return SettingsPageView(controller: controller);
case 4:
return AboutPageView(controller: controller);
default:
return HomePageView(controller: controller);
}
}
}
class _Sidebar extends StatelessWidget {
const _Sidebar({required this.controller});
final ShellController controller;
@override
Widget build(BuildContext context) {
final settings = controller.settings;
return Container(
width: GcSize.sidebar,
color: GcColors.sideBg,
padding: const EdgeInsets.fromLTRB(
GcSpace.xl, GcSpace.xxl, GcSpace.lg, GcSpace.lg),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
_brand(),
const SizedBox(height: GcSpace.xxxl),
const Padding(
padding: EdgeInsets.only(left: 10, bottom: GcSpace.sm),
child: Text(
'MENU',
style: TextStyle(
fontSize: 11,
height: 1.2,
letterSpacing: 1.4,
fontWeight: FontWeight.w600,
color: Color(0xFF5C6A80),
),
),
),
for (var i = 0; i < _navItems.length; i++)
_NavButton(
item: _navItems[i],
active: controller.index == i,
onTap: () => controller.goTo(i),
),
const Spacer(),
Container(height: 1, color: GcColors.line),
const SizedBox(height: GcSpace.md),
Padding(
padding: const EdgeInsets.only(left: 10),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
Text(
'v${settings?.version ?? '—'}',
style: TextStyle(
fontSize: 12,
height: 1.4,
fontWeight: FontWeight.w600,
color: GcColors.muted,
),
),
const SizedBox(height: 2),
Text(
settings?.platform ?? '—',
style: TextStyle(
fontSize: 11.5,
height: 1.4,
color: GcColors.ghost,
),
),
],
),
),
],
),
);
}
/// 品牌区:一个渐变圆角标 + 名称 + 一句定位。
Widget _brand() {
return Row(
children: <Widget>[
Container(
width: 32,
height: 32,
alignment: Alignment.center,
decoration: BoxDecoration(
color: GcColors.accentSoft,
borderRadius: BorderRadius.circular(9),
border: Border.all(
color: Color.alphaBlend(
GcColors.accent.withOpacity(0.35), GcColors.sideBg),
),
),
child: Text(
'◎',
style: TextStyle(fontSize: 16, height: 1.1, color: GcColors.accent),
),
),
const SizedBox(width: GcSpace.md),
Expanded(
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
mainAxisSize: MainAxisSize.min,
children: <Widget>[
Text(
'Morris GC',
style: TextStyle(
fontSize: 14,
height: 1.3,
fontWeight: FontWeight.w600,
color: GcColors.ink,
),
),
const SizedBox(height: 1),
Text(
'SCIENCE · CLASSROOM',
style: TextStyle(
fontSize: 10,
height: 1.3,
letterSpacing: 0.9,
fontWeight: FontWeight.w600,
color: GcColors.ghost,
),
),
],
),
),
],
);
}
}
class _NavButton extends StatelessWidget {
const _NavButton({
required this.item,
required this.active,
required this.onTap,
});
final _NavItem item;
final bool active;
final VoidCallback onTap;
@override
Widget build(BuildContext context) {
return Padding(
padding: const EdgeInsets.only(bottom: GcSpace.xs),
child: Material(
color: active ? GcColors.accentSoft : Colors.transparent,
borderRadius: BorderRadius.circular(GcRadius.control),
child: InkWell(
borderRadius: BorderRadius.circular(GcRadius.control),
onTap: onTap,
hoverColor: GcColors.surfaceHover,
child: Padding(
padding: const EdgeInsets.symmetric(
horizontal: GcSpace.md,
vertical: 11,
),
child: Row(
children: <Widget>[
Icon(
item.icon,
size: 17,
color: active ? GcColors.accent : GcColors.faint,
),
const SizedBox(width: GcSpace.md),
Text(
T(item.labelKey),
style: TextStyle(
fontSize: 13.5,
height: 1.2,
fontWeight: active ? FontWeight.w600 : FontWeight.w400,
color: active ? GcColors.accent : GcColors.muted,
),
),
],
),
),
),
),
);
}
}
class _UpdateBar extends StatelessWidget {
const _UpdateBar({required this.controller});
final ShellController controller;
@override
Widget build(BuildContext context) {
return Container(
decoration: BoxDecoration(
color: GcColors.surface,
border: Border(top: BorderSide(color: GcColors.line)),
),
padding: const EdgeInsets.symmetric(
horizontal: GcSpace.xxl,
vertical: GcSpace.md,
),
child: Row(
children: <Widget>[
Icon(
Icons.sync_rounded,
size: 18,
color: GcColors.accent,
),
const SizedBox(width: GcSpace.md),
Expanded(
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
mainAxisSize: MainAxisSize.min,
children: <Widget>[
Text(
controller.updateStatus,
style: TextStyle(
fontSize: 13,
height: 1.35,
fontWeight: FontWeight.w600,
color: GcColors.ink,
),
overflow: TextOverflow.ellipsis,
),
if (controller.updateDetail.isNotEmpty)
Text(
controller.updateDetail,
style: TextStyle(
fontSize: 12,
height: 1.4,
color: GcColors.faint,
),
overflow: TextOverflow.ellipsis,
),
if (controller.launcherNotice.isNotEmpty)
Text(
controller.launcherNotice,
style: TextStyle(
fontSize: 12,
height: 1.4,
color: GcColors.warn,
),
),
],
),
),
if (controller.updateBusy) ...<Widget>[
const SizedBox(width: GcSpace.lg),
SizedBox(
width: 140,
child: ClipRRect(
borderRadius: BorderRadius.circular(3),
child: LinearProgressIndicator(
value: controller.updateProgress > 0
? controller.updateProgress.clamp(0, 1).toDouble()
: null,
minHeight: 4,
),
),
),
],
const SizedBox(width: GcSpace.lg),
TextButton(
onPressed: controller.updateBusy
? null
: () => controller.checkUpdate(force: true),
child: Text(T('update.checkNow')),
),
],
),
);
}
}
class _BackendDown extends StatelessWidget {
const _BackendDown({required this.controller});
final ShellController controller;
@override
Widget build(BuildContext context) {
return Center(
child: ConstrainedBox(
constraints: const BoxConstraints(maxWidth: 520),
child: GcCard(
padding: const EdgeInsets.all(GcSpace.xxl),
child: Column(
mainAxisSize: MainAxisSize.min,
crossAxisAlignment: CrossAxisAlignment.start,
children: <Widget>[
Row(
children: <Widget>[
Icon(Icons.error_outline_rounded,
size: 20, color: GcColors.danger),
const SizedBox(width: GcSpace.sm),
Text(
T('common.error'),
style: TextStyle(
fontSize: 16,
height: 1.35,
fontWeight: FontWeight.w600,
color: GcColors.ink,
),
),
],
),
const SizedBox(height: GcSpace.md),
GcHint(controller.loadError ?? ''),
const SizedBox(height: GcSpace.xs),
GcHint('${T('set.backend')}: ${controller.api.baseUrl}'),
const SizedBox(height: GcSpace.lg),
FilledButton(
onPressed: controller.bootstrap,
child: Text(T('common.retry')),
),
],
),
),
),
);
}
}
File diff suppressed because it is too large. Load diff
-1
View File
@@ -1 +0,0 @@
flutter/ephemeral
-146
View File
@@ -1,146 +0,0 @@
# Project-level configuration.
cmake_minimum_required(VERSION 3.10)
project(runner LANGUAGES CXX)
# The name of the executable created for the application. Change this to change
# the on-disk name of your application.
set(BINARY_NAME "GC-UI")
# The unique GTK application identifier for this application. See:
# https://wiki.gnome.org/HowDoI/ChooseApplicationID
set(APPLICATION_ID "com.xhmcl.GC")
# Explicitly opt in to modern CMake behaviors to avoid warnings with recent
# versions of CMake.
cmake_policy(SET CMP0063 NEW)
# Load bundled libraries from the lib/ directory relative to the binary.
set(CMAKE_INSTALL_RPATH "$ORIGIN/lib")
# Root filesystem for cross-building.
if(FLUTTER_TARGET_PLATFORM_SYSROOT)
set(CMAKE_SYSROOT ${FLUTTER_TARGET_PLATFORM_SYSROOT})
set(CMAKE_FIND_ROOT_PATH ${CMAKE_SYSROOT})
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
endif()
# Define build configuration options.
if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
set(CMAKE_BUILD_TYPE "Debug" CACHE
STRING "Flutter build mode" FORCE)
set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS
"Debug" "Profile" "Release")
endif()
# Compilation settings that should be applied to most targets.
#
# Be cautious about adding new options here, as plugins use this function by
# default. In most cases, you should add new options to specific targets instead
# of modifying this function.
function(APPLY_STANDARD_SETTINGS TARGET)
target_compile_features(${TARGET} PUBLIC cxx_std_14)
target_compile_options(${TARGET} PRIVATE -Wall -Werror)
target_compile_options(${TARGET} PRIVATE "$<$<NOT:$<CONFIG:Debug>>:-O3>")
target_compile_definitions(${TARGET} PRIVATE "$<$<NOT:$<CONFIG:Debug>>:NDEBUG>")
endfunction()
# Flutter library and tool build rules.
set(FLUTTER_MANAGED_DIR "${CMAKE_CURRENT_SOURCE_DIR}/flutter")
add_subdirectory(${FLUTTER_MANAGED_DIR})
# System-level dependencies.
find_package(PkgConfig REQUIRED)
pkg_check_modules(GTK REQUIRED IMPORTED_TARGET gtk+-3.0)
add_definitions(-DAPPLICATION_ID="${APPLICATION_ID}")
# Define the application target. To change its name, change BINARY_NAME above,
# not the value here, or `flutter run` will no longer work.
#
# Any new source files that you add to the application should be added here.
add_executable(${BINARY_NAME}
"main.cc"
"my_application.cc"
"${FLUTTER_MANAGED_DIR}/generated_plugin_registrant.cc"
)
# Apply the standard set of build settings. This can be removed for applications
# that need different build settings.
apply_standard_settings(${BINARY_NAME})
# Add dependency libraries. Add any application-specific dependencies here.
target_link_libraries(${BINARY_NAME} PRIVATE flutter)
target_link_libraries(${BINARY_NAME} PRIVATE PkgConfig::GTK)
# Run the Flutter tool portions of the build. This must not be removed.
add_dependencies(${BINARY_NAME} flutter_assemble)
# Only the install-generated bundle's copy of the executable will launch
# correctly, since the resources must in the right relative locations. To avoid
# people trying to run the unbundled copy, put it in a subdirectory instead of
# the default top-level location.
set_target_properties(${BINARY_NAME}
PROPERTIES
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/intermediates_do_not_run"
)
# Generated plugin build rules, which manage building the plugins and adding
# them to the application.
include(flutter/generated_plugins.cmake)
# === Installation ===
# By default, "installing" just makes a relocatable bundle in the build
# directory.
set(BUILD_BUNDLE_DIR "${PROJECT_BINARY_DIR}/bundle")
# 无条件强制安装到 build 目录下的 bundle:某些环境下 CMAKE_INSTALL_PREFIX
# 会被初始化成 /usr/local,导致 flutter build linux 声称成功、却把产物装进
# 系统目录,build/.../bundle 是空的。
set(CMAKE_INSTALL_PREFIX "${BUILD_BUNDLE_DIR}" CACHE PATH "Flutter bundle 输出目录" FORCE)
# Start with a clean build bundle directory every time.
install(CODE "
file(REMOVE_RECURSE \"${BUILD_BUNDLE_DIR}/\")
" COMPONENT Runtime)
set(INSTALL_BUNDLE_DATA_DIR "${CMAKE_INSTALL_PREFIX}/data")
set(INSTALL_BUNDLE_LIB_DIR "${CMAKE_INSTALL_PREFIX}/lib")
install(TARGETS ${BINARY_NAME} RUNTIME DESTINATION "${CMAKE_INSTALL_PREFIX}"
COMPONENT Runtime)
install(FILES "${FLUTTER_ICU_DATA_FILE}" DESTINATION "${INSTALL_BUNDLE_DATA_DIR}"
COMPONENT Runtime)
install(FILES "${FLUTTER_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}"
COMPONENT Runtime)
foreach(bundled_library ${PLUGIN_BUNDLED_LIBRARIES})
install(FILES "${bundled_library}"
DESTINATION "${INSTALL_BUNDLE_LIB_DIR}"
COMPONENT Runtime)
endforeach(bundled_library)
# Copy the native assets provided by the build.dart from all packages.
set(NATIVE_ASSETS_DIR "${PROJECT_BUILD_DIR}native_assets/linux/")
install(DIRECTORY "${NATIVE_ASSETS_DIR}"
DESTINATION "${INSTALL_BUNDLE_LIB_DIR}"
COMPONENT Runtime)
# Fully re-copy the assets directory on each build to avoid having stale files
# from a previous install.
set(FLUTTER_ASSET_DIR_NAME "flutter_assets")
install(CODE "
file(REMOVE_RECURSE \"${INSTALL_BUNDLE_DATA_DIR}/${FLUTTER_ASSET_DIR_NAME}\")
" COMPONENT Runtime)
install(DIRECTORY "${PROJECT_BUILD_DIR}/${FLUTTER_ASSET_DIR_NAME}"
DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" COMPONENT Runtime)
# Install the AOT library on non-Debug builds only.
if(NOT CMAKE_BUILD_TYPE MATCHES "Debug")
install(FILES "${AOT_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}"
COMPONENT Runtime)
endif()
@@ -1,88 +0,0 @@
# This file controls Flutter-level build steps. It should not be edited.
cmake_minimum_required(VERSION 3.10)
set(EPHEMERAL_DIR "${CMAKE_CURRENT_SOURCE_DIR}/ephemeral")
# Configuration provided via flutter tool.
include(${EPHEMERAL_DIR}/generated_config.cmake)
# TODO: Move the rest of this into files in ephemeral. See
# https://github.com/flutter/flutter/issues/57146.
# Serves the same purpose as list(TRANSFORM ... PREPEND ...),
# which isn't available in 3.10.
function(list_prepend LIST_NAME PREFIX)
set(NEW_LIST "")
foreach(element ${${LIST_NAME}})
list(APPEND NEW_LIST "${PREFIX}${element}")
endforeach(element)
set(${LIST_NAME} "${NEW_LIST}" PARENT_SCOPE)
endfunction()
# === Flutter Library ===
# System-level dependencies.
find_package(PkgConfig REQUIRED)
pkg_check_modules(GTK REQUIRED IMPORTED_TARGET gtk+-3.0)
pkg_check_modules(GLIB REQUIRED IMPORTED_TARGET glib-2.0)
pkg_check_modules(GIO REQUIRED IMPORTED_TARGET gio-2.0)
set(FLUTTER_LIBRARY "${EPHEMERAL_DIR}/libflutter_linux_gtk.so")
# Published to parent scope for install step.
set(FLUTTER_LIBRARY ${FLUTTER_LIBRARY} PARENT_SCOPE)
set(FLUTTER_ICU_DATA_FILE "${EPHEMERAL_DIR}/icudtl.dat" PARENT_SCOPE)
set(PROJECT_BUILD_DIR "${PROJECT_DIR}/build/" PARENT_SCOPE)
set(AOT_LIBRARY "${PROJECT_DIR}/build/lib/libapp.so" PARENT_SCOPE)
list(APPEND FLUTTER_LIBRARY_HEADERS
"fl_basic_message_channel.h"
"fl_binary_codec.h"
"fl_binary_messenger.h"
"fl_dart_project.h"
"fl_engine.h"
"fl_json_message_codec.h"
"fl_json_method_codec.h"
"fl_message_codec.h"
"fl_method_call.h"
"fl_method_channel.h"
"fl_method_codec.h"
"fl_method_response.h"
"fl_plugin_registrar.h"
"fl_plugin_registry.h"
"fl_standard_message_codec.h"
"fl_standard_method_codec.h"
"fl_string_codec.h"
"fl_value.h"
"fl_view.h"
"flutter_linux.h"
)
list_prepend(FLUTTER_LIBRARY_HEADERS "${EPHEMERAL_DIR}/flutter_linux/")
add_library(flutter INTERFACE)
target_include_directories(flutter INTERFACE
"${EPHEMERAL_DIR}"
)
target_link_libraries(flutter INTERFACE "${FLUTTER_LIBRARY}")
target_link_libraries(flutter INTERFACE
PkgConfig::GTK
PkgConfig::GLIB
PkgConfig::GIO
)
add_dependencies(flutter flutter_assemble)
# === Flutter tool backend ===
# _phony_ is a non-existent file to force this command to run every time,
# since currently there's no way to get a full input/output list from the
# flutter tool.
add_custom_command(
OUTPUT ${FLUTTER_LIBRARY} ${FLUTTER_LIBRARY_HEADERS}
${CMAKE_CURRENT_BINARY_DIR}/_phony_
COMMAND ${CMAKE_COMMAND} -E env
${FLUTTER_TOOL_ENVIRONMENT}
"${FLUTTER_ROOT}/packages/flutter_tools/bin/tool_backend.sh"
${FLUTTER_TARGET_PLATFORM} ${CMAKE_BUILD_TYPE}
VERBATIM
)
add_custom_target(flutter_assemble DEPENDS
"${FLUTTER_LIBRARY}"
${FLUTTER_LIBRARY_HEADERS}
)
-6
View File
@@ -1,6 +0,0 @@
#include "my_application.h"
int main(int argc, char** argv) {
g_autoptr(MyApplication) app = my_application_new();
return g_application_run(G_APPLICATION(app), argc, argv);
}
-124
View File
@@ -1,124 +0,0 @@
#include "my_application.h"
#include <flutter_linux/flutter_linux.h>
#ifdef GDK_WINDOWING_X11
#include <gdk/gdkx.h>
#endif
#include "flutter/generated_plugin_registrant.h"
struct _MyApplication {
GtkApplication parent_instance;
char** dart_entrypoint_arguments;
};
G_DEFINE_TYPE(MyApplication, my_application, GTK_TYPE_APPLICATION)
// Implements GApplication::activate.
static void my_application_activate(GApplication* application) {
MyApplication* self = MY_APPLICATION(application);
GtkWindow* window =
GTK_WINDOW(gtk_application_window_new(GTK_APPLICATION(application)));
// Use a header bar when running in GNOME as this is the common style used
// by applications and is the setup most users will be using (e.g. Ubuntu
// desktop).
// If running on X and not using GNOME then just use a traditional title bar
// in case the window manager does more exotic layout, e.g. tiling.
// If running on Wayland assume the header bar will work (may need changing
// if future cases occur).
gboolean use_header_bar = TRUE;
#ifdef GDK_WINDOWING_X11
GdkScreen* screen = gtk_window_get_screen(window);
if (GDK_IS_X11_SCREEN(screen)) {
const gchar* wm_name = gdk_x11_screen_get_window_manager_name(screen);
if (g_strcmp0(wm_name, "GNOME Shell") != 0) {
use_header_bar = FALSE;
}
}
#endif
if (use_header_bar) {
GtkHeaderBar* header_bar = GTK_HEADER_BAR(gtk_header_bar_new());
gtk_widget_show(GTK_WIDGET(header_bar));
gtk_header_bar_set_title(header_bar, "Morris GC");
gtk_header_bar_set_show_close_button(header_bar, TRUE);
gtk_window_set_titlebar(window, GTK_WIDGET(header_bar));
} else {
gtk_window_set_title(window, "Morris GC");
}
gtk_window_set_default_size(window, 1280, 720);
gtk_widget_show(GTK_WIDGET(window));
g_autoptr(FlDartProject) project = fl_dart_project_new();
fl_dart_project_set_dart_entrypoint_arguments(project, self->dart_entrypoint_arguments);
FlView* view = fl_view_new(project);
gtk_widget_show(GTK_WIDGET(view));
gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(view));
fl_register_plugins(FL_PLUGIN_REGISTRY(view));
gtk_widget_grab_focus(GTK_WIDGET(view));
}
// Implements GApplication::local_command_line.
static gboolean my_application_local_command_line(GApplication* application, gchar*** arguments, int* exit_status) {
MyApplication* self = MY_APPLICATION(application);
// Strip out the first argument as it is the binary name.
self->dart_entrypoint_arguments = g_strdupv(*arguments + 1);
g_autoptr(GError) error = nullptr;
if (!g_application_register(application, nullptr, &error)) {
g_warning("Failed to register: %s", error->message);
*exit_status = 1;
return TRUE;
}
g_application_activate(application);
*exit_status = 0;
return TRUE;
}
// Implements GApplication::startup.
static void my_application_startup(GApplication* application) {
//MyApplication* self = MY_APPLICATION(object);
// Perform any actions required at application startup.
G_APPLICATION_CLASS(my_application_parent_class)->startup(application);
}
// Implements GApplication::shutdown.
static void my_application_shutdown(GApplication* application) {
//MyApplication* self = MY_APPLICATION(object);
// Perform any actions required at application shutdown.
G_APPLICATION_CLASS(my_application_parent_class)->shutdown(application);
}
// Implements GObject::dispose.
static void my_application_dispose(GObject* object) {
MyApplication* self = MY_APPLICATION(object);
g_clear_pointer(&self->dart_entrypoint_arguments, g_strfreev);
G_OBJECT_CLASS(my_application_parent_class)->dispose(object);
}
static void my_application_class_init(MyApplicationClass* klass) {
G_APPLICATION_CLASS(klass)->activate = my_application_activate;
G_APPLICATION_CLASS(klass)->local_command_line = my_application_local_command_line;
G_APPLICATION_CLASS(klass)->startup = my_application_startup;
G_APPLICATION_CLASS(klass)->shutdown = my_application_shutdown;
G_OBJECT_CLASS(klass)->dispose = my_application_dispose;
}
static void my_application_init(MyApplication* self) {}
MyApplication* my_application_new() {
return MY_APPLICATION(g_object_new(my_application_get_type(),
"application-id", APPLICATION_ID,
"flags", G_APPLICATION_NON_UNIQUE,
nullptr));
}
-18
View File
@@ -1,18 +0,0 @@
#ifndef FLUTTER_MY_APPLICATION_H_
#define FLUTTER_MY_APPLICATION_H_
#include <gtk/gtk.h>
G_DECLARE_FINAL_TYPE(MyApplication, my_application, MY, APPLICATION,
GtkApplication)
/**
* my_application_new:
*
* Creates a new Flutter-based application.
*
* Returns: a new #MyApplication.
*/
MyApplication* my_application_new();
#endif // FLUTTER_MY_APPLICATION_H_
-7
View File
@@ -1,7 +0,0 @@
# Flutter-related
**/Flutter/ephemeral/
**/Pods/
# Xcode-related
**/dgph
**/xcuserdata/
@@ -1,2 +0,0 @@
#include? "Pods/Target Support Files/Pods-Runner/Pods-Runner.debug.xcconfig"
#include "ephemeral/Flutter-Generated.xcconfig"
@@ -1,2 +0,0 @@
#include? "Pods/Target Support Files/Pods-Runner/Pods-Runner.release.xcconfig"
#include "ephemeral/Flutter-Generated.xcconfig"
-47
View File
@@ -1,47 +0,0 @@
platform :osx, '12.0'
# CocoaPods analytics sends network stats synchronously affecting flutter build latency.
ENV['COCOAPODS_DISABLE_STATS'] = 'true'
project 'Runner', {
'Debug' => :debug,
'Profile' => :release,
'Release' => :release,
}
def flutter_root
generated_xcode_build_settings_path = File.expand_path(File.join('..', 'Flutter', 'ephemeral', 'Flutter-Generated.xcconfig'), __FILE__)
unless File.exist?(generated_xcode_build_settings_path)
raise "#{generated_xcode_build_settings_path} must exist. If you're running pod install manually, make sure \"flutter pub get\" is executed first"
end
File.foreach(generated_xcode_build_settings_path) do |line|
matches = line.match(/FLUTTER_ROOT\=(.*)/)
return matches[1].strip if matches
end
raise "FLUTTER_ROOT not found in #{generated_xcode_build_settings_path}. Try deleting Flutter-Generated.xcconfig, then run \"flutter pub get\""
end
require File.expand_path(File.join('packages', 'flutter_tools', 'bin', 'podhelper'), flutter_root)
flutter_macos_podfile_setup
target 'Runner' do
use_frameworks!
use_modular_headers!
flutter_install_all_macos_pods File.dirname(File.realpath(__FILE__))
target 'RunnerTests' do
inherit! :search_paths
end
end
post_install do |installer|
installer.pods_project.targets.each do |target|
flutter_additional_macos_build_settings(target)
# Xcode 27 起最低部署目标为 12.0;逐个 pod 提升,避免旧 pod 的 10.13/10.14 报错。
target.build_configurations.each do |config|
config.build_settings['MACOSX_DEPLOYMENT_TARGET'] = '12.0'
end
end
end
@@ -1,801 +0,0 @@
// !$*UTF8*$!
{
archiveVersion = 1;
classes = {
};
objectVersion = 54;
objects = {
/* Begin PBXAggregateTarget section */
33CC111A2044C6BA0003C045 /* Flutter Assemble */ = {
isa = PBXAggregateTarget;
buildConfigurationList = 33CC111B2044C6BA0003C045 /* Build configuration list for PBXAggregateTarget "Flutter Assemble" */;
buildPhases = (
33CC111E2044C6BF0003C045 /* ShellScript */,
);
dependencies = (
);
name = "Flutter Assemble";
productName = FLX;
};
/* End PBXAggregateTarget section */
/* Begin PBXBuildFile section */
331C80D8294CF71000263BE5 /* RunnerTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 331C80D7294CF71000263BE5 /* RunnerTests.swift */; };
335BBD1B22A9A15E00E9071D /* GeneratedPluginRegistrant.swift in Sources */ = {isa = PBXBuildFile; fileRef = 335BBD1A22A9A15E00E9071D /* GeneratedPluginRegistrant.swift */; };
33CC10F12044A3C60003C045 /* AppDelegate.swift in Sources */ = {isa = PBXBuildFile; fileRef = 33CC10F02044A3C60003C045 /* AppDelegate.swift */; };
33CC10F32044A3C60003C045 /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 33CC10F22044A3C60003C045 /* Assets.xcassets */; };
33CC10F62044A3C60003C045 /* MainMenu.xib in Resources */ = {isa = PBXBuildFile; fileRef = 33CC10F42044A3C60003C045 /* MainMenu.xib */; };
33CC11132044BFA00003C045 /* MainFlutterWindow.swift in Sources */ = {isa = PBXBuildFile; fileRef = 33CC11122044BFA00003C045 /* MainFlutterWindow.swift */; };
6115A3AA09C0554E004627A7 /* Pods_RunnerTests.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 8206FEA4073335056184BFE7 /* Pods_RunnerTests.framework */; };
D97968A61668AD5CB0F4AD81 /* Pods_Runner.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = A3E308B8A5C9BFB85DE87E1A /* Pods_Runner.framework */; };
/* End PBXBuildFile section */
/* Begin PBXContainerItemProxy section */
331C80D9294CF71000263BE5 /* PBXContainerItemProxy */ = {
isa = PBXContainerItemProxy;
containerPortal = 33CC10E52044A3C60003C045 /* Project object */;
proxyType = 1;
remoteGlobalIDString = 33CC10EC2044A3C60003C045;
remoteInfo = Runner;
};
33CC111F2044C79F0003C045 /* PBXContainerItemProxy */ = {
isa = PBXContainerItemProxy;
containerPortal = 33CC10E52044A3C60003C045 /* Project object */;
proxyType = 1;
remoteGlobalIDString = 33CC111A2044C6BA0003C045;
remoteInfo = FLX;
};
/* End PBXContainerItemProxy section */
/* Begin PBXCopyFilesBuildPhase section */
33CC110E2044A8840003C045 /* Bundle Framework */ = {
isa = PBXCopyFilesBuildPhase;
buildActionMask = 2147483647;
dstPath = "";
dstSubfolderSpec = 10;
files = (
);
name = "Bundle Framework";
runOnlyForDeploymentPostprocessing = 0;
};
/* End PBXCopyFilesBuildPhase section */
/* Begin PBXFileReference section */
182DFB26FB114E38C6E212AD /* Pods-RunnerTests.profile.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-RunnerTests.profile.xcconfig"; path = "Target Support Files/Pods-RunnerTests/Pods-RunnerTests.profile.xcconfig"; sourceTree = "<group>"; };
280B76C220FC1F5F9A19A983 /* Pods-Runner.debug.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-Runner.debug.xcconfig"; path = "Target Support Files/Pods-Runner/Pods-Runner.debug.xcconfig"; sourceTree = "<group>"; };
331C80D5294CF71000263BE5 /* RunnerTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = RunnerTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
331C80D7294CF71000263BE5 /* RunnerTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RunnerTests.swift; sourceTree = "<group>"; };
333000ED22D3DE5D00554162 /* Warnings.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = Warnings.xcconfig; sourceTree = "<group>"; };
335BBD1A22A9A15E00E9071D /* GeneratedPluginRegistrant.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = GeneratedPluginRegistrant.swift; sourceTree = "<group>"; };
33CC10ED2044A3C60003C045 /* gc_ui.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = gc_ui.app; sourceTree = BUILT_PRODUCTS_DIR; };
33CC10F02044A3C60003C045 /* AppDelegate.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AppDelegate.swift; sourceTree = "<group>"; };
33CC10F22044A3C60003C045 /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; name = Assets.xcassets; path = Runner/Assets.xcassets; sourceTree = "<group>"; };
33CC10F52044A3C60003C045 /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.xib; name = Base; path = Base.lproj/MainMenu.xib; sourceTree = "<group>"; };
33CC10F72044A3C60003C045 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; name = Info.plist; path = Runner/Info.plist; sourceTree = "<group>"; };
33CC11122044BFA00003C045 /* MainFlutterWindow.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MainFlutterWindow.swift; sourceTree = "<group>"; };
33CEB47222A05771004F2AC0 /* Flutter-Debug.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = "Flutter-Debug.xcconfig"; sourceTree = "<group>"; };
33CEB47422A05771004F2AC0 /* Flutter-Release.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = "Flutter-Release.xcconfig"; sourceTree = "<group>"; };
33CEB47722A0578A004F2AC0 /* Flutter-Generated.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; name = "Flutter-Generated.xcconfig"; path = "ephemeral/Flutter-Generated.xcconfig"; sourceTree = "<group>"; };
33E51913231747F40026EE4D /* DebugProfile.entitlements */ = {isa = PBXFileReference; lastKnownFileType = text.plist.entitlements; path = DebugProfile.entitlements; sourceTree = "<group>"; };
33E51914231749380026EE4D /* Release.entitlements */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.entitlements; path = Release.entitlements; sourceTree = "<group>"; };
33E5194F232828860026EE4D /* AppInfo.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = AppInfo.xcconfig; sourceTree = "<group>"; };
41137AAB2DF4C73772AD6680 /* Pods-Runner.profile.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-Runner.profile.xcconfig"; path = "Target Support Files/Pods-Runner/Pods-Runner.profile.xcconfig"; sourceTree = "<group>"; };
75F404C3BC9A85A0940A1E7A /* Pods-RunnerTests.debug.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-RunnerTests.debug.xcconfig"; path = "Target Support Files/Pods-RunnerTests/Pods-RunnerTests.debug.xcconfig"; sourceTree = "<group>"; };
7AFA3C8E1D35360C0083082E /* Release.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = Release.xcconfig; sourceTree = "<group>"; };
8206FEA4073335056184BFE7 /* Pods_RunnerTests.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Pods_RunnerTests.framework; sourceTree = BUILT_PRODUCTS_DIR; };
8892D008E4FA6821A291BE17 /* Pods-RunnerTests.release.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-RunnerTests.release.xcconfig"; path = "Target Support Files/Pods-RunnerTests/Pods-RunnerTests.release.xcconfig"; sourceTree = "<group>"; };
8EFF00FDE3D0667C00609F10 /* Pods-Runner.release.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-Runner.release.xcconfig"; path = "Target Support Files/Pods-Runner/Pods-Runner.release.xcconfig"; sourceTree = "<group>"; };
9740EEB21CF90195004384FC /* Debug.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = Debug.xcconfig; sourceTree = "<group>"; };
A3E308B8A5C9BFB85DE87E1A /* Pods_Runner.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Pods_Runner.framework; sourceTree = BUILT_PRODUCTS_DIR; };
/* End PBXFileReference section */
/* Begin PBXFrameworksBuildPhase section */
331C80D2294CF70F00263BE5 /* Frameworks */ = {
isa = PBXFrameworksBuildPhase;
buildActionMask = 2147483647;
files = (
6115A3AA09C0554E004627A7 /* Pods_RunnerTests.framework in Frameworks */,
);
runOnlyForDeploymentPostprocessing = 0;
};
33CC10EA2044A3C60003C045 /* Frameworks */ = {
isa = PBXFrameworksBuildPhase;
buildActionMask = 2147483647;
files = (
D97968A61668AD5CB0F4AD81 /* Pods_Runner.framework in Frameworks */,
);
runOnlyForDeploymentPostprocessing = 0;
};
/* End PBXFrameworksBuildPhase section */
/* Begin PBXGroup section */
331C80D6294CF71000263BE5 /* RunnerTests */ = {
isa = PBXGroup;
children = (
331C80D7294CF71000263BE5 /* RunnerTests.swift */,
);
path = RunnerTests;
sourceTree = "<group>";
};
33BA886A226E78AF003329D5 /* Configs */ = {
isa = PBXGroup;
children = (
33E5194F232828860026EE4D /* AppInfo.xcconfig */,
9740EEB21CF90195004384FC /* Debug.xcconfig */,
7AFA3C8E1D35360C0083082E /* Release.xcconfig */,
333000ED22D3DE5D00554162 /* Warnings.xcconfig */,
);
path = Configs;
sourceTree = "<group>";
};
33CC10E42044A3C60003C045 = {
isa = PBXGroup;
children = (
33FAB671232836740065AC1E /* Runner */,
33CEB47122A05771004F2AC0 /* Flutter */,
331C80D6294CF71000263BE5 /* RunnerTests */,
33CC10EE2044A3C60003C045 /* Products */,
D73912EC22F37F3D000D13A0 /* Frameworks */,
A82E8A367D68D5C69E25C9BA /* Pods */,
);
sourceTree = "<group>";
};
33CC10EE2044A3C60003C045 /* Products */ = {
isa = PBXGroup;
children = (
33CC10ED2044A3C60003C045 /* gc_ui.app */,
331C80D5294CF71000263BE5 /* RunnerTests.xctest */,
);
name = Products;
sourceTree = "<group>";
};
33CC11242044D66E0003C045 /* Resources */ = {
isa = PBXGroup;
children = (
33CC10F22044A3C60003C045 /* Assets.xcassets */,
33CC10F42044A3C60003C045 /* MainMenu.xib */,
33CC10F72044A3C60003C045 /* Info.plist */,
);
name = Resources;
path = ..;
sourceTree = "<group>";
};
33CEB47122A05771004F2AC0 /* Flutter */ = {
isa = PBXGroup;
children = (
335BBD1A22A9A15E00E9071D /* GeneratedPluginRegistrant.swift */,
33CEB47222A05771004F2AC0 /* Flutter-Debug.xcconfig */,
33CEB47422A05771004F2AC0 /* Flutter-Release.xcconfig */,
33CEB47722A0578A004F2AC0 /* Flutter-Generated.xcconfig */,
);
path = Flutter;
sourceTree = "<group>";
};
33FAB671232836740065AC1E /* Runner */ = {
isa = PBXGroup;
children = (
33CC10F02044A3C60003C045 /* AppDelegate.swift */,
33CC11122044BFA00003C045 /* MainFlutterWindow.swift */,
33E51913231747F40026EE4D /* DebugProfile.entitlements */,
33E51914231749380026EE4D /* Release.entitlements */,
33CC11242044D66E0003C045 /* Resources */,
33BA886A226E78AF003329D5 /* Configs */,
);
path = Runner;
sourceTree = "<group>";
};
A82E8A367D68D5C69E25C9BA /* Pods */ = {
isa = PBXGroup;
children = (
280B76C220FC1F5F9A19A983 /* Pods-Runner.debug.xcconfig */,
8EFF00FDE3D0667C00609F10 /* Pods-Runner.release.xcconfig */,
41137AAB2DF4C73772AD6680 /* Pods-Runner.profile.xcconfig */,
75F404C3BC9A85A0940A1E7A /* Pods-RunnerTests.debug.xcconfig */,
8892D008E4FA6821A291BE17 /* Pods-RunnerTests.release.xcconfig */,
182DFB26FB114E38C6E212AD /* Pods-RunnerTests.profile.xcconfig */,
);
name = Pods;
path = Pods;
sourceTree = "<group>";
};
D73912EC22F37F3D000D13A0 /* Frameworks */ = {
isa = PBXGroup;
children = (
A3E308B8A5C9BFB85DE87E1A /* Pods_Runner.framework */,
8206FEA4073335056184BFE7 /* Pods_RunnerTests.framework */,
);
name = Frameworks;
sourceTree = "<group>";
};
/* End PBXGroup section */
/* Begin PBXNativeTarget section */
331C80D4294CF70F00263BE5 /* RunnerTests */ = {
isa = PBXNativeTarget;
buildConfigurationList = 331C80DE294CF71000263BE5 /* Build configuration list for PBXNativeTarget "RunnerTests" */;
buildPhases = (
EBEBA5BB2F5B8B60B8CBB8D2 /* [CP] Check Pods Manifest.lock */,
331C80D1294CF70F00263BE5 /* Sources */,
331C80D2294CF70F00263BE5 /* Frameworks */,
331C80D3294CF70F00263BE5 /* Resources */,
);
buildRules = (
);
dependencies = (
331C80DA294CF71000263BE5 /* PBXTargetDependency */,
);
name = RunnerTests;
productName = RunnerTests;
productReference = 331C80D5294CF71000263BE5 /* RunnerTests.xctest */;
productType = "com.apple.product-type.bundle.unit-test";
};
33CC10EC2044A3C60003C045 /* Runner */ = {
isa = PBXNativeTarget;
buildConfigurationList = 33CC10FB2044A3C60003C045 /* Build configuration list for PBXNativeTarget "Runner" */;
buildPhases = (
6098269FDFAA15D26448E434 /* [CP] Check Pods Manifest.lock */,
33CC10E92044A3C60003C045 /* Sources */,
33CC10EA2044A3C60003C045 /* Frameworks */,
33CC10EB2044A3C60003C045 /* Resources */,
33CC110E2044A8840003C045 /* Bundle Framework */,
3399D490228B24CF009A79C7 /* ShellScript */,
A1BACCAA4E3E0600DECC8167 /* [CP] Embed Pods Frameworks */,
);
buildRules = (
);
dependencies = (
33CC11202044C79F0003C045 /* PBXTargetDependency */,
);
name = Runner;
productName = Runner;
productReference = 33CC10ED2044A3C60003C045 /* gc_ui.app */;
productType = "com.apple.product-type.application";
};
/* End PBXNativeTarget section */
/* Begin PBXProject section */
33CC10E52044A3C60003C045 /* Project object */ = {
isa = PBXProject;
attributes = {
BuildIndependentTargetsInParallel = YES;
LastSwiftUpdateCheck = 0920;
LastUpgradeCheck = 1510;
ORGANIZATIONNAME = "";
TargetAttributes = {
331C80D4294CF70F00263BE5 = {
CreatedOnToolsVersion = 14.0;
TestTargetID = 33CC10EC2044A3C60003C045;
};
33CC10EC2044A3C60003C045 = {
CreatedOnToolsVersion = 9.2;
LastSwiftMigration = 1100;
ProvisioningStyle = Automatic;
SystemCapabilities = {
com.apple.Sandbox = {
enabled = 1;
};
};
};
33CC111A2044C6BA0003C045 = {
CreatedOnToolsVersion = 9.2;
ProvisioningStyle = Manual;
};
};
};
buildConfigurationList = 33CC10E82044A3C60003C045 /* Build configuration list for PBXProject "Runner" */;
compatibilityVersion = "Xcode 9.3";
developmentRegion = en;
hasScannedForEncodings = 0;
knownRegions = (
en,
Base,
);
mainGroup = 33CC10E42044A3C60003C045;
productRefGroup = 33CC10EE2044A3C60003C045 /* Products */;
projectDirPath = "";
projectRoot = "";
targets = (
33CC10EC2044A3C60003C045 /* Runner */,
331C80D4294CF70F00263BE5 /* RunnerTests */,
33CC111A2044C6BA0003C045 /* Flutter Assemble */,
);
};
/* End PBXProject section */
/* Begin PBXResourcesBuildPhase section */
331C80D3294CF70F00263BE5 /* Resources */ = {
isa = PBXResourcesBuildPhase;
buildActionMask = 2147483647;
files = (
);
runOnlyForDeploymentPostprocessing = 0;
};
33CC10EB2044A3C60003C045 /* Resources */ = {
isa = PBXResourcesBuildPhase;
buildActionMask = 2147483647;
files = (
33CC10F32044A3C60003C045 /* Assets.xcassets in Resources */,
33CC10F62044A3C60003C045 /* MainMenu.xib in Resources */,
);
runOnlyForDeploymentPostprocessing = 0;
};
/* End PBXResourcesBuildPhase section */
/* Begin PBXShellScriptBuildPhase section */
3399D490228B24CF009A79C7 /* ShellScript */ = {
isa = PBXShellScriptBuildPhase;
alwaysOutOfDate = 1;
buildActionMask = 2147483647;
files = (
);
inputFileListPaths = (
);
inputPaths = (
);
outputFileListPaths = (
);
outputPaths = (
);
runOnlyForDeploymentPostprocessing = 0;
shellPath = /bin/sh;
shellScript = "echo \"$PRODUCT_NAME.app\" > \"$PROJECT_DIR\"/Flutter/ephemeral/.app_filename && \"$FLUTTER_ROOT\"/packages/flutter_tools/bin/macos_assemble.sh embed\n";
};
33CC111E2044C6BF0003C045 /* ShellScript */ = {
isa = PBXShellScriptBuildPhase;
buildActionMask = 2147483647;
files = (
);
inputFileListPaths = (
Flutter/ephemeral/FlutterInputs.xcfilelist,
);
inputPaths = (
Flutter/ephemeral/tripwire,
);
outputFileListPaths = (
Flutter/ephemeral/FlutterOutputs.xcfilelist,
);
outputPaths = (
);
runOnlyForDeploymentPostprocessing = 0;
shellPath = /bin/sh;
shellScript = "\"$FLUTTER_ROOT\"/packages/flutter_tools/bin/macos_assemble.sh && touch Flutter/ephemeral/tripwire";
};
6098269FDFAA15D26448E434 /* [CP] Check Pods Manifest.lock */ = {
isa = PBXShellScriptBuildPhase;
buildActionMask = 2147483647;
files = (
);
inputFileListPaths = (
);
inputPaths = (
"${PODS_PODFILE_DIR_PATH}/Podfile.lock",
"${PODS_ROOT}/Manifest.lock",
);
name = "[CP] Check Pods Manifest.lock";
outputFileListPaths = (
);
outputPaths = (
"$(DERIVED_FILE_DIR)/Pods-Runner-checkManifestLockResult.txt",
);
runOnlyForDeploymentPostprocessing = 0;
shellPath = /bin/sh;
shellScript = "diff \"${PODS_PODFILE_DIR_PATH}/Podfile.lock\" \"${PODS_ROOT}/Manifest.lock\" > /dev/null\nif [ $? != 0 ] ; then\n # print error to STDERR\n echo \"error: The sandbox is not in sync with the Podfile.lock. Run 'pod install' or update your CocoaPods installation.\" >&2\n exit 1\nfi\n# This output is used by Xcode 'outputs' to avoid re-running this script phase.\necho \"SUCCESS\" > \"${SCRIPT_OUTPUT_FILE_0}\"\n";
showEnvVarsInLog = 0;
};
A1BACCAA4E3E0600DECC8167 /* [CP] Embed Pods Frameworks */ = {
isa = PBXShellScriptBuildPhase;
buildActionMask = 2147483647;
files = (
);
inputFileListPaths = (
"${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-frameworks-${CONFIGURATION}-input-files.xcfilelist",
);
name = "[CP] Embed Pods Frameworks";
outputFileListPaths = (
"${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-frameworks-${CONFIGURATION}-output-files.xcfilelist",
);
runOnlyForDeploymentPostprocessing = 0;
shellPath = /bin/sh;
shellScript = "\"${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-frameworks.sh\"\n";
showEnvVarsInLog = 0;
};
EBEBA5BB2F5B8B60B8CBB8D2 /* [CP] Check Pods Manifest.lock */ = {
isa = PBXShellScriptBuildPhase;
buildActionMask = 2147483647;
files = (
);
inputFileListPaths = (
);
inputPaths = (
"${PODS_PODFILE_DIR_PATH}/Podfile.lock",
"${PODS_ROOT}/Manifest.lock",
);
name = "[CP] Check Pods Manifest.lock";
outputFileListPaths = (
);
outputPaths = (
"$(DERIVED_FILE_DIR)/Pods-RunnerTests-checkManifestLockResult.txt",
);
runOnlyForDeploymentPostprocessing = 0;
shellPath = /bin/sh;
shellScript = "diff \"${PODS_PODFILE_DIR_PATH}/Podfile.lock\" \"${PODS_ROOT}/Manifest.lock\" > /dev/null\nif [ $? != 0 ] ; then\n # print error to STDERR\n echo \"error: The sandbox is not in sync with the Podfile.lock. Run 'pod install' or update your CocoaPods installation.\" >&2\n exit 1\nfi\n# This output is used by Xcode 'outputs' to avoid re-running this script phase.\necho \"SUCCESS\" > \"${SCRIPT_OUTPUT_FILE_0}\"\n";
showEnvVarsInLog = 0;
};
/* End PBXShellScriptBuildPhase section */
/* Begin PBXSourcesBuildPhase section */
331C80D1294CF70F00263BE5 /* Sources */ = {
isa = PBXSourcesBuildPhase;
buildActionMask = 2147483647;
files = (
331C80D8294CF71000263BE5 /* RunnerTests.swift in Sources */,
);
runOnlyForDeploymentPostprocessing = 0;
};
33CC10E92044A3C60003C045 /* Sources */ = {
isa = PBXSourcesBuildPhase;
buildActionMask = 2147483647;
files = (
33CC11132044BFA00003C045 /* MainFlutterWindow.swift in Sources */,
33CC10F12044A3C60003C045 /* AppDelegate.swift in Sources */,
335BBD1B22A9A15E00E9071D /* GeneratedPluginRegistrant.swift in Sources */,
);
runOnlyForDeploymentPostprocessing = 0;
};
/* End PBXSourcesBuildPhase section */
/* Begin PBXTargetDependency section */
331C80DA294CF71000263BE5 /* PBXTargetDependency */ = {
isa = PBXTargetDependency;
target = 33CC10EC2044A3C60003C045 /* Runner */;
targetProxy = 331C80D9294CF71000263BE5 /* PBXContainerItemProxy */;
};
33CC11202044C79F0003C045 /* PBXTargetDependency */ = {
isa = PBXTargetDependency;
target = 33CC111A2044C6BA0003C045 /* Flutter Assemble */;
targetProxy = 33CC111F2044C79F0003C045 /* PBXContainerItemProxy */;
};
/* End PBXTargetDependency section */
/* Begin PBXVariantGroup section */
33CC10F42044A3C60003C045 /* MainMenu.xib */ = {
isa = PBXVariantGroup;
children = (
33CC10F52044A3C60003C045 /* Base */,
);
name = MainMenu.xib;
path = Runner;
sourceTree = "<group>";
};
/* End PBXVariantGroup section */
/* Begin XCBuildConfiguration section */
331C80DB294CF71000263BE5 /* Debug */ = {
isa = XCBuildConfiguration;
baseConfigurationReference = 75F404C3BC9A85A0940A1E7A /* Pods-RunnerTests.debug.xcconfig */;
buildSettings = {
BUNDLE_LOADER = "$(TEST_HOST)";
CURRENT_PROJECT_VERSION = 1;
GENERATE_INFOPLIST_FILE = YES;
MARKETING_VERSION = 1.0;
PRODUCT_BUNDLE_IDENTIFIER = com.morris.gc.gcUi.RunnerTests;
PRODUCT_NAME = "$(TARGET_NAME)";
SWIFT_VERSION = 5.0;
TEST_HOST = "$(BUILT_PRODUCTS_DIR)/gc_ui.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/gc_ui";
};
name = Debug;
};
331C80DC294CF71000263BE5 /* Release */ = {
isa = XCBuildConfiguration;
baseConfigurationReference = 8892D008E4FA6821A291BE17 /* Pods-RunnerTests.release.xcconfig */;
buildSettings = {
BUNDLE_LOADER = "$(TEST_HOST)";
CURRENT_PROJECT_VERSION = 1;
GENERATE_INFOPLIST_FILE = YES;
MARKETING_VERSION = 1.0;
PRODUCT_BUNDLE_IDENTIFIER = com.morris.gc.gcUi.RunnerTests;
PRODUCT_NAME = "$(TARGET_NAME)";
SWIFT_VERSION = 5.0;
TEST_HOST = "$(BUILT_PRODUCTS_DIR)/gc_ui.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/gc_ui";
};
name = Release;
};
331C80DD294CF71000263BE5 /* Profile */ = {
isa = XCBuildConfiguration;
baseConfigurationReference = 182DFB26FB114E38C6E212AD /* Pods-RunnerTests.profile.xcconfig */;
buildSettings = {
BUNDLE_LOADER = "$(TEST_HOST)";
CURRENT_PROJECT_VERSION = 1;
GENERATE_INFOPLIST_FILE = YES;
MARKETING_VERSION = 1.0;
PRODUCT_BUNDLE_IDENTIFIER = com.morris.gc.gcUi.RunnerTests;
PRODUCT_NAME = "$(TARGET_NAME)";
SWIFT_VERSION = 5.0;
TEST_HOST = "$(BUILT_PRODUCTS_DIR)/gc_ui.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/gc_ui";
};
name = Profile;
};
338D0CE9231458BD00FA5F75 /* Profile */ = {
isa = XCBuildConfiguration;
baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */;
buildSettings = {
ALWAYS_SEARCH_USER_PATHS = NO;
ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES;
CLANG_ANALYZER_NONNULL = YES;
CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
CLANG_CXX_LANGUAGE_STANDARD = "gnu++14";
CLANG_CXX_LIBRARY = "libc++";
CLANG_ENABLE_MODULES = YES;
CLANG_ENABLE_OBJC_ARC = YES;
CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
CLANG_WARN_BOOL_CONVERSION = YES;
CLANG_WARN_CONSTANT_CONVERSION = YES;
CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
CLANG_WARN_EMPTY_BODY = YES;
CLANG_WARN_ENUM_CONVERSION = YES;
CLANG_WARN_INFINITE_RECURSION = YES;
CLANG_WARN_INT_CONVERSION = YES;
CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
CLANG_WARN_SUSPICIOUS_MOVE = YES;
CODE_SIGN_IDENTITY = "-";
COPY_PHASE_STRIP = NO;
DEAD_CODE_STRIPPING = YES;
DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
ENABLE_NS_ASSERTIONS = NO;
ENABLE_STRICT_OBJC_MSGSEND = YES;
ENABLE_USER_SCRIPT_SANDBOXING = NO;
GCC_C_LANGUAGE_STANDARD = gnu11;
GCC_NO_COMMON_BLOCKS = YES;
GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
GCC_WARN_UNUSED_FUNCTION = YES;
GCC_WARN_UNUSED_VARIABLE = YES;
MACOSX_DEPLOYMENT_TARGET = 12.0;
MTL_ENABLE_DEBUG_INFO = NO;
SDKROOT = macosx;
SWIFT_COMPILATION_MODE = wholemodule;
SWIFT_OPTIMIZATION_LEVEL = "-O";
};
name = Profile;
};
338D0CEA231458BD00FA5F75 /* Profile */ = {
isa = XCBuildConfiguration;
baseConfigurationReference = 33E5194F232828860026EE4D /* AppInfo.xcconfig */;
buildSettings = {
ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
CLANG_ENABLE_MODULES = YES;
CODE_SIGN_ENTITLEMENTS = Runner/DebugProfile.entitlements;
CODE_SIGN_STYLE = Automatic;
COMBINE_HIDPI_IMAGES = YES;
INFOPLIST_FILE = Runner/Info.plist;
LD_RUNPATH_SEARCH_PATHS = (
"$(inherited)",
"@executable_path/../Frameworks",
);
PROVISIONING_PROFILE_SPECIFIER = "";
SWIFT_VERSION = 5.0;
};
name = Profile;
};
338D0CEB231458BD00FA5F75 /* Profile */ = {
isa = XCBuildConfiguration;
buildSettings = {
CODE_SIGN_STYLE = Manual;
PRODUCT_NAME = "$(TARGET_NAME)";
};
name = Profile;
};
33CC10F92044A3C60003C045 /* Debug */ = {
isa = XCBuildConfiguration;
baseConfigurationReference = 9740EEB21CF90195004384FC /* Debug.xcconfig */;
buildSettings = {
ALWAYS_SEARCH_USER_PATHS = NO;
ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES;
CLANG_ANALYZER_NONNULL = YES;
CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
CLANG_CXX_LANGUAGE_STANDARD = "gnu++14";
CLANG_CXX_LIBRARY = "libc++";
CLANG_ENABLE_MODULES = YES;
CLANG_ENABLE_OBJC_ARC = YES;
CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
CLANG_WARN_BOOL_CONVERSION = YES;
CLANG_WARN_CONSTANT_CONVERSION = YES;
CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
CLANG_WARN_EMPTY_BODY = YES;
CLANG_WARN_ENUM_CONVERSION = YES;
CLANG_WARN_INFINITE_RECURSION = YES;
CLANG_WARN_INT_CONVERSION = YES;
CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
CLANG_WARN_SUSPICIOUS_MOVE = YES;
CODE_SIGN_IDENTITY = "-";
COPY_PHASE_STRIP = NO;
DEAD_CODE_STRIPPING = YES;
DEBUG_INFORMATION_FORMAT = dwarf;
ENABLE_STRICT_OBJC_MSGSEND = YES;
ENABLE_TESTABILITY = YES;
ENABLE_USER_SCRIPT_SANDBOXING = NO;
GCC_C_LANGUAGE_STANDARD = gnu11;
GCC_DYNAMIC_NO_PIC = NO;
GCC_NO_COMMON_BLOCKS = YES;
GCC_OPTIMIZATION_LEVEL = 0;
GCC_PREPROCESSOR_DEFINITIONS = (
"DEBUG=1",
"$(inherited)",
);
GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
GCC_WARN_UNUSED_FUNCTION = YES;
GCC_WARN_UNUSED_VARIABLE = YES;
MACOSX_DEPLOYMENT_TARGET = 12.0;
MTL_ENABLE_DEBUG_INFO = YES;
ONLY_ACTIVE_ARCH = YES;
SDKROOT = macosx;
SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG;
SWIFT_OPTIMIZATION_LEVEL = "-Onone";
};
name = Debug;
};
33CC10FA2044A3C60003C045 /* Release */ = {
isa = XCBuildConfiguration;
baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */;
buildSettings = {
ALWAYS_SEARCH_USER_PATHS = NO;
ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES;
CLANG_ANALYZER_NONNULL = YES;
CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE;
CLANG_CXX_LANGUAGE_STANDARD = "gnu++14";
CLANG_CXX_LIBRARY = "libc++";
CLANG_ENABLE_MODULES = YES;
CLANG_ENABLE_OBJC_ARC = YES;
CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
CLANG_WARN_BOOL_CONVERSION = YES;
CLANG_WARN_CONSTANT_CONVERSION = YES;
CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
CLANG_WARN_DOCUMENTATION_COMMENTS = YES;
CLANG_WARN_EMPTY_BODY = YES;
CLANG_WARN_ENUM_CONVERSION = YES;
CLANG_WARN_INFINITE_RECURSION = YES;
CLANG_WARN_INT_CONVERSION = YES;
CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
CLANG_WARN_SUSPICIOUS_MOVE = YES;
CODE_SIGN_IDENTITY = "-";
COPY_PHASE_STRIP = NO;
DEAD_CODE_STRIPPING = YES;
DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
ENABLE_NS_ASSERTIONS = NO;
ENABLE_STRICT_OBJC_MSGSEND = YES;
ENABLE_USER_SCRIPT_SANDBOXING = NO;
GCC_C_LANGUAGE_STANDARD = gnu11;
GCC_NO_COMMON_BLOCKS = YES;
GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
GCC_WARN_UNUSED_FUNCTION = YES;
GCC_WARN_UNUSED_VARIABLE = YES;
MACOSX_DEPLOYMENT_TARGET = 12.0;
MTL_ENABLE_DEBUG_INFO = NO;
SDKROOT = macosx;
SWIFT_COMPILATION_MODE = wholemodule;
SWIFT_OPTIMIZATION_LEVEL = "-O";
};
name = Release;
};
33CC10FC2044A3C60003C045 /* Debug */ = {
isa = XCBuildConfiguration;
baseConfigurationReference = 33E5194F232828860026EE4D /* AppInfo.xcconfig */;
buildSettings = {
ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
CLANG_ENABLE_MODULES = YES;
CODE_SIGN_ENTITLEMENTS = Runner/DebugProfile.entitlements;
CODE_SIGN_STYLE = Automatic;
COMBINE_HIDPI_IMAGES = YES;
INFOPLIST_FILE = Runner/Info.plist;
LD_RUNPATH_SEARCH_PATHS = (
"$(inherited)",
"@executable_path/../Frameworks",
);
PROVISIONING_PROFILE_SPECIFIER = "";
SWIFT_OPTIMIZATION_LEVEL = "-Onone";
SWIFT_VERSION = 5.0;
};
name = Debug;
};
33CC10FD2044A3C60003C045 /* Release */ = {
isa = XCBuildConfiguration;
baseConfigurationReference = 33E5194F232828860026EE4D /* AppInfo.xcconfig */;
buildSettings = {
ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
CLANG_ENABLE_MODULES = YES;
CODE_SIGN_ENTITLEMENTS = Runner/Release.entitlements;
CODE_SIGN_STYLE = Automatic;
COMBINE_HIDPI_IMAGES = YES;
INFOPLIST_FILE = Runner/Info.plist;
LD_RUNPATH_SEARCH_PATHS = (
"$(inherited)",
"@executable_path/../Frameworks",
);
PROVISIONING_PROFILE_SPECIFIER = "";
SWIFT_VERSION = 5.0;
};
name = Release;
};
33CC111C2044C6BA0003C045 /* Debug */ = {
isa = XCBuildConfiguration;
buildSettings = {
CODE_SIGN_STYLE = Manual;
PRODUCT_NAME = "$(TARGET_NAME)";
};
name = Debug;
};
33CC111D2044C6BA0003C045 /* Release */ = {
isa = XCBuildConfiguration;
buildSettings = {
CODE_SIGN_STYLE = Automatic;
PRODUCT_NAME = "$(TARGET_NAME)";
};
name = Release;
};
/* End XCBuildConfiguration section */
/* Begin XCConfigurationList section */
331C80DE294CF71000263BE5 /* Build configuration list for PBXNativeTarget "RunnerTests" */ = {
isa = XCConfigurationList;
buildConfigurations = (
331C80DB294CF71000263BE5 /* Debug */,
331C80DC294CF71000263BE5 /* Release */,
331C80DD294CF71000263BE5 /* Profile */,
);
defaultConfigurationIsVisible = 0;
defaultConfigurationName = Release;
};
33CC10E82044A3C60003C045 /* Build configuration list for PBXProject "Runner" */ = {
isa = XCConfigurationList;
buildConfigurations = (
33CC10F92044A3C60003C045 /* Debug */,
33CC10FA2044A3C60003C045 /* Release */,
338D0CE9231458BD00FA5F75 /* Profile */,
);
defaultConfigurationIsVisible = 0;
defaultConfigurationName = Release;
};
33CC10FB2044A3C60003C045 /* Build configuration list for PBXNativeTarget "Runner" */ = {
isa = XCConfigurationList;
buildConfigurations = (
33CC10FC2044A3C60003C045 /* Debug */,
33CC10FD2044A3C60003C045 /* Release */,
338D0CEA231458BD00FA5F75 /* Profile */,
);
defaultConfigurationIsVisible = 0;
defaultConfigurationName = Release;
};
33CC111B2044C6BA0003C045 /* Build configuration list for PBXAggregateTarget "Flutter Assemble" */ = {
isa = XCConfigurationList;
buildConfigurations = (
33CC111C2044C6BA0003C045 /* Debug */,
33CC111D2044C6BA0003C045 /* Release */,
338D0CEB231458BD00FA5F75 /* Profile */,
);
defaultConfigurationIsVisible = 0;
defaultConfigurationName = Release;
};
/* End XCConfigurationList section */
};
rootObject = 33CC10E52044A3C60003C045 /* Project object */;
}
@@ -1,8 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>IDEDidComputeMac32BitWarning</key>
<true/>
</dict>
</plist>
@@ -1,98 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<Scheme
LastUpgradeVersion = "1510"
version = "1.3">
<BuildAction
parallelizeBuildables = "YES"
buildImplicitDependencies = "YES">
<BuildActionEntries>
<BuildActionEntry
buildForTesting = "YES"
buildForRunning = "YES"
buildForProfiling = "YES"
buildForArchiving = "YES"
buildForAnalyzing = "YES">
<BuildableReference
BuildableIdentifier = "primary"
BlueprintIdentifier = "33CC10EC2044A3C60003C045"
BuildableName = "gc_ui.app"
BlueprintName = "Runner"
ReferencedContainer = "container:Runner.xcodeproj">
</BuildableReference>
</BuildActionEntry>
</BuildActionEntries>
</BuildAction>
<TestAction
buildConfiguration = "Debug"
selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
shouldUseLaunchSchemeArgsEnv = "YES">
<MacroExpansion>
<BuildableReference
BuildableIdentifier = "primary"
BlueprintIdentifier = "33CC10EC2044A3C60003C045"
BuildableName = "gc_ui.app"
BlueprintName = "Runner"
ReferencedContainer = "container:Runner.xcodeproj">
</BuildableReference>
</MacroExpansion>
<Testables>
<TestableReference
skipped = "NO"
parallelizable = "YES">
<BuildableReference
BuildableIdentifier = "primary"
BlueprintIdentifier = "331C80D4294CF70F00263BE5"
BuildableName = "RunnerTests.xctest"
BlueprintName = "RunnerTests"
ReferencedContainer = "container:Runner.xcodeproj">
</BuildableReference>
</TestableReference>
</Testables>
</TestAction>
<LaunchAction
buildConfiguration = "Debug"
selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
launchStyle = "0"
useCustomWorkingDirectory = "NO"
ignoresPersistentStateOnLaunch = "NO"
debugDocumentVersioning = "YES"
debugServiceExtension = "internal"
allowLocationSimulation = "YES">
<BuildableProductRunnable
runnableDebuggingMode = "0">
<BuildableReference
BuildableIdentifier = "primary"
BlueprintIdentifier = "33CC10EC2044A3C60003C045"
BuildableName = "gc_ui.app"
BlueprintName = "Runner"
ReferencedContainer = "container:Runner.xcodeproj">
</BuildableReference>
</BuildableProductRunnable>
</LaunchAction>
<ProfileAction
buildConfiguration = "Profile"
shouldUseLaunchSchemeArgsEnv = "YES"
savedToolIdentifier = ""
useCustomWorkingDirectory = "NO"
debugDocumentVersioning = "YES">
<BuildableProductRunnable
runnableDebuggingMode = "0">
<BuildableReference
BuildableIdentifier = "primary"
BlueprintIdentifier = "33CC10EC2044A3C60003C045"
BuildableName = "gc_ui.app"
BlueprintName = "Runner"
ReferencedContainer = "container:Runner.xcodeproj">
</BuildableReference>
</BuildableProductRunnable>
</ProfileAction>
<AnalyzeAction
buildConfiguration = "Debug">
</AnalyzeAction>
<ArchiveAction
buildConfiguration = "Release"
revealArchiveInOrganizer = "YES">
</ArchiveAction>
</Scheme>
@@ -1,10 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<Workspace
version = "1.0">
<FileRef
location = "group:Runner.xcodeproj">
</FileRef>
<FileRef
location = "group:Pods/Pods.xcodeproj">
</FileRef>
</Workspace>
@@ -1,8 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>IDEDidComputeMac32BitWarning</key>
<true/>
</dict>
</plist>
@@ -1,9 +0,0 @@
import Cocoa
import FlutterMacOS
@main
class AppDelegate: FlutterAppDelegate {
override func applicationShouldTerminateAfterLastWindowClosed(_ sender: NSApplication) -> Bool {
return true
}
}
@@ -1,68 +0,0 @@
{
"images" : [
{
"size" : "16x16",
"idiom" : "mac",
"filename" : "app_icon_16.png",
"scale" : "1x"
},
{
"size" : "16x16",
"idiom" : "mac",
"filename" : "app_icon_32.png",
"scale" : "2x"
},
{
"size" : "32x32",
"idiom" : "mac",
"filename" : "app_icon_32.png",
"scale" : "1x"
},
{
"size" : "32x32",
"idiom" : "mac",
"filename" : "app_icon_64.png",
"scale" : "2x"
},
{
"size" : "128x128",
"idiom" : "mac",
"filename" : "app_icon_128.png",
"scale" : "1x"
},
{
"size" : "128x128",
"idiom" : "mac",
"filename" : "app_icon_256.png",
"scale" : "2x"
},
{
"size" : "256x256",
"idiom" : "mac",
"filename" : "app_icon_256.png",
"scale" : "1x"
},
{
"size" : "256x256",
"idiom" : "mac",
"filename" : "app_icon_512.png",
"scale" : "2x"
},
{
"size" : "512x512",
"idiom" : "mac",
"filename" : "app_icon_512.png",
"scale" : "1x"
},
{
"size" : "512x512",
"idiom" : "mac",
"filename" : "app_icon_1024.png",
"scale" : "2x"
}
],
"info" : {
"version" : 1,
"author" : "xcode"
}
}
Loaded 100 of 315 files, more files were not shown because too many files have changed in this diff. Show more