527 lines
18 KiB
Swift
527 lines
18 KiB
Swift
import SwiftUI
|
||
import DuooomiBleSDK
|
||
|
||
// MARK: - CDN Helper
|
||
|
||
private enum CDNHelper {
|
||
static let host = "https://cdn.bowong.cc/"
|
||
|
||
static func ensureFullUrl(_ keyOrUrl: String) -> String {
|
||
if keyOrUrl.hasPrefix("http://") || keyOrUrl.hasPrefix("https://") {
|
||
return keyOrUrl
|
||
}
|
||
let key = keyOrUrl.hasPrefix("/") ? String(keyOrUrl.dropFirst()) : keyOrUrl
|
||
return host + key
|
||
}
|
||
|
||
static func isImage(_ url: String) -> Bool {
|
||
let ext = URL(string: url)?.pathExtension.lowercased() ?? ""
|
||
return ["jpg", "jpeg", "png", "webp", "gif"].contains(ext)
|
||
}
|
||
}
|
||
|
||
// MARK: - View
|
||
|
||
struct WrapperTestView: View {
|
||
@EnvironmentObject var sdk: DuooomiBleSDK
|
||
|
||
@State private var userId = "test-user-001"
|
||
@State private var videoUrl = "https://cdn.bowong.cc/material/569f48a8e29f47859b3a9808be37f94c.mp4"
|
||
@State private var aniUrlDirect = "https://cdn.bowong.cc/material/c59affcbe0654bf8b69aaadc1900ac3f.ani"
|
||
// Firmware update
|
||
@State private var firmwareInfo: FirmwareInfo? = nil
|
||
@State private var firmwareLoading = false
|
||
@State private var firmwareError: String? = nil
|
||
@State private var isBusy = false
|
||
@State private var connectingDeviceId: String?
|
||
@State private var deviceFiles: [String] = []
|
||
@State private var logs: [LogLine] = []
|
||
|
||
struct LogLine: Identifiable {
|
||
let id = UUID()
|
||
let time = Date()
|
||
let level: Level
|
||
let message: String
|
||
enum Level { case info, success, error }
|
||
}
|
||
|
||
var body: some View {
|
||
List {
|
||
statusSection
|
||
scanSection
|
||
deviceSection
|
||
fileSection
|
||
directAniSection
|
||
firmwareSection
|
||
deviceFilesSection
|
||
logSection
|
||
}
|
||
.navigationTitle("Native SDK Test")
|
||
.scrollDismissesKeyboard(.interactively)
|
||
.onTapGesture {
|
||
UIApplication.shared.sendAction(
|
||
#selector(UIResponder.resignFirstResponder),
|
||
to: nil, from: nil, for: nil
|
||
)
|
||
}
|
||
}
|
||
|
||
// MARK: - Sections
|
||
|
||
private var statusSection: some View {
|
||
Section("Status") {
|
||
LabeledContent("btState", value: sdk.btState.rawValue)
|
||
LabeledContent("isActivated", value: sdk.isActivated ? "YES" : "NO")
|
||
LabeledContent("busy", value: isBusy ? "YES" : "no")
|
||
if let err = sdk.error {
|
||
Text(err).foregroundStyle(.red).font(.caption)
|
||
}
|
||
}
|
||
}
|
||
|
||
private var scanSection: some View {
|
||
Section("Scan") {
|
||
HStack {
|
||
Button("Scan") {
|
||
sdk.scan()
|
||
log("→ scan()")
|
||
}
|
||
.buttonStyle(.borderedProminent)
|
||
|
||
Button("Stop") {
|
||
sdk.stopScan()
|
||
log("→ stopScan()")
|
||
}
|
||
.buttonStyle(.bordered)
|
||
}
|
||
|
||
ForEach(sdk.discoveredDevices) { device in
|
||
HStack {
|
||
VStack(alignment: .leading) {
|
||
Text(device.name ?? "Unknown")
|
||
Text(device.id).font(.caption2).foregroundStyle(.secondary)
|
||
}
|
||
Spacer()
|
||
Text("\(device.rssi) dBm")
|
||
.font(.caption)
|
||
.foregroundStyle(.secondary)
|
||
|
||
if sdk.connectedDevice?.id == device.id {
|
||
Button("Disconnect") {
|
||
Task { await runDisconnect() }
|
||
}
|
||
.buttonStyle(.bordered)
|
||
.controlSize(.small)
|
||
.tint(.red)
|
||
} else if connectingDeviceId == device.id {
|
||
ProgressView().controlSize(.small)
|
||
} else {
|
||
Button("Connect") {
|
||
Task { await runConnect(deviceId: device.id) }
|
||
}
|
||
.buttonStyle(.bordered)
|
||
.controlSize(.small)
|
||
.disabled(connectingDeviceId != nil)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
private var deviceSection: some View {
|
||
Section("Device") {
|
||
LabeledContent("Name", value: sdk.connectedDevice?.name ?? "—")
|
||
LabeledContent("ID", value: sdk.connectedDevice?.id ?? "—")
|
||
LabeledContent("Brand", value: sdk.deviceInfo?.brand ?? "—")
|
||
LabeledContent("Size", value: sdk.deviceInfo?.size ?? "—")
|
||
LabeledContent(
|
||
"Power",
|
||
value: sdk.deviceInfo.map { "\($0.powerlevel)%" } ?? "—"
|
||
)
|
||
LabeledContent(
|
||
"Storage",
|
||
value: sdk.deviceInfo.map { "\($0.freespace)/\($0.allspace)" } ?? "—"
|
||
)
|
||
LabeledContent("Version", value: sdk.version.isEmpty ? "—" : sdk.version)
|
||
|
||
HStack {
|
||
Button("getDeviceInfo") { Task { await runGetDeviceInfo() } }
|
||
Button("getVersion") { Task { await runGetVersion() } }
|
||
}
|
||
.buttonStyle(.bordered)
|
||
|
||
HStack {
|
||
TextField("userId", text: $userId)
|
||
.textFieldStyle(.roundedBorder)
|
||
Button("bind") { Task { await runBind() } }
|
||
.buttonStyle(.bordered)
|
||
Button("unbind") { Task { await runUnbind() } }
|
||
.buttonStyle(.bordered)
|
||
}
|
||
}
|
||
}
|
||
|
||
private var fileSection: some View {
|
||
Section("Transfer") {
|
||
if sdk.transferProgress > 0 {
|
||
ProgressView(value: Double(sdk.transferProgress), total: 100) {
|
||
Text("Transfer: \(sdk.transferProgress)%").font(.caption)
|
||
}
|
||
}
|
||
|
||
TextField("videoUrl (source)", text: $videoUrl)
|
||
.textFieldStyle(.roundedBorder)
|
||
.autocapitalization(.none)
|
||
.disableAutocorrection(true)
|
||
|
||
Button("Convert → PrepareTransfer → Transfer") {
|
||
Task { await runConvertAndTransfer() }
|
||
}
|
||
.buttonStyle(.borderedProminent)
|
||
.disabled(videoUrl.isEmpty || sdk.connectedDevice == nil)
|
||
}
|
||
}
|
||
|
||
private var directAniSection: some View {
|
||
Section("Direct ANI Transfer") {
|
||
TextField("aniUrl (https://... .ani)", text: $aniUrlDirect)
|
||
.textFieldStyle(.roundedBorder)
|
||
.autocapitalization(.none)
|
||
.disableAutocorrection(true)
|
||
|
||
Button("Prepare → Transfer ANI") {
|
||
Task { await runTransferAniDirect() }
|
||
}
|
||
.buttonStyle(.borderedProminent)
|
||
.disabled(aniUrlDirect.isEmpty || sdk.connectedDevice == nil || isBusy)
|
||
}
|
||
}
|
||
|
||
private var firmwareSection: some View {
|
||
Section("Firmware Update") {
|
||
LabeledContent("Current Version", value: sdk.version.isEmpty ? "—" : sdk.version)
|
||
LabeledContent("Brand", value: sdk.deviceInfo?.brand ?? "—")
|
||
|
||
if let info = firmwareInfo {
|
||
VStack(alignment: .leading, spacing: 6) {
|
||
Text("Latest: \(info.version)")
|
||
Text(info.fileUrl).font(.caption2).foregroundStyle(.secondary)
|
||
if let notes = info.notes, !notes.isEmpty {
|
||
Text(notes).font(.caption)
|
||
}
|
||
}
|
||
}
|
||
|
||
if let err = firmwareError {
|
||
Text(err).font(.caption).foregroundStyle(.red)
|
||
}
|
||
|
||
HStack {
|
||
Button(firmwareLoading ? "Fetching..." : "Get Update Info") {
|
||
Task { await runFetchFirmwareInfo() }
|
||
}
|
||
.buttonStyle(.bordered)
|
||
.disabled(firmwareLoading || sdk.connectedDevice == nil || sdk.deviceInfo?.brand == nil)
|
||
|
||
Button("Upgrade Firmware") {
|
||
Task { await runUpgradeFirmware() }
|
||
}
|
||
.buttonStyle(.borderedProminent)
|
||
.disabled(firmwareInfo?.fileUrl.isEmpty != false || sdk.connectedDevice == nil || isBusy)
|
||
}
|
||
}
|
||
}
|
||
|
||
private var deviceFilesSection: some View {
|
||
Section("Device Files (\(deviceFiles.count))") {
|
||
if deviceFiles.isEmpty {
|
||
Text("Bind 后显示设备文件")
|
||
.font(.caption)
|
||
.foregroundStyle(.secondary)
|
||
}
|
||
ForEach(deviceFiles, id: \.self) { rawKey in
|
||
let fileUrl = CDNHelper.ensureFullUrl(rawKey)
|
||
HStack {
|
||
if CDNHelper.isImage(fileUrl), let url = URL(string: fileUrl) {
|
||
AsyncImage(url: url) { phase in
|
||
switch phase {
|
||
case .success(let image):
|
||
image.resizable().aspectRatio(contentMode: .fill)
|
||
case .failure:
|
||
Image(systemName: "photo").foregroundStyle(.secondary)
|
||
default:
|
||
ProgressView()
|
||
}
|
||
}
|
||
.frame(width: 50, height: 50)
|
||
.clipShape(RoundedRectangle(cornerRadius: 6))
|
||
} else {
|
||
Image(systemName: "film")
|
||
.frame(width: 50, height: 50)
|
||
.foregroundStyle(.secondary)
|
||
}
|
||
|
||
Text(URL(string: fileUrl)?.lastPathComponent ?? fileUrl)
|
||
.font(.caption)
|
||
.lineLimit(1)
|
||
|
||
Spacer()
|
||
|
||
Button(role: .destructive) {
|
||
Task { await runDeleteFile(rawKey) }
|
||
} label: {
|
||
Image(systemName: "trash")
|
||
}
|
||
.buttonStyle(.borderless)
|
||
.disabled(isBusy)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
private var logSection: some View {
|
||
Section("Log (\(logs.count))") {
|
||
ForEach(logs.prefix(80)) { line in
|
||
Text(line.message)
|
||
.font(.caption)
|
||
.foregroundStyle(color(for: line.level))
|
||
}
|
||
}
|
||
}
|
||
|
||
private func color(for level: LogLine.Level) -> Color {
|
||
switch level {
|
||
case .info: return .primary
|
||
case .success: return .green
|
||
case .error: return .red
|
||
}
|
||
}
|
||
|
||
// MARK: - Logging
|
||
|
||
private func log(_ message: String, level: LogLine.Level = .info) {
|
||
logs.insert(LogLine(level: level, message: message), at: 0)
|
||
if logs.count > 200 { logs.removeLast() }
|
||
}
|
||
|
||
// MARK: - Async runners
|
||
|
||
private func runConnect(deviceId: String) async {
|
||
connectingDeviceId = deviceId
|
||
defer { connectingDeviceId = nil }
|
||
log("→ connect(\(deviceId))")
|
||
do {
|
||
let device = try await sdk.connect(deviceId: deviceId)
|
||
log("connect ✓ \(device.name ?? device.id)", level: .success)
|
||
} catch {
|
||
log("connect ✗ \(error.localizedDescription)", level: .error)
|
||
}
|
||
}
|
||
|
||
private func runDisconnect() async {
|
||
log("→ disconnect")
|
||
do {
|
||
try await sdk.disconnect()
|
||
deviceFiles = []
|
||
log("disconnect ✓", level: .success)
|
||
} catch {
|
||
log("disconnect ✗ \(error.localizedDescription)", level: .error)
|
||
}
|
||
}
|
||
|
||
private func runGetDeviceInfo() async {
|
||
isBusy = true
|
||
defer { isBusy = false }
|
||
log("→ getDeviceInfo")
|
||
do {
|
||
let info = try await sdk.getDeviceInfo()
|
||
log(
|
||
"getDeviceInfo ✓ brand=\(info.brand) size=\(info.size) battery=\(info.powerlevel)",
|
||
level: .success
|
||
)
|
||
} catch {
|
||
log("getDeviceInfo ✗ \(error.localizedDescription)", level: .error)
|
||
}
|
||
}
|
||
|
||
private func runGetVersion() async {
|
||
isBusy = true
|
||
defer { isBusy = false }
|
||
log("→ getVersion")
|
||
do {
|
||
let info = try await sdk.getVersion()
|
||
log("getVersion ✓ \(info.version)", level: .success)
|
||
} catch {
|
||
log("getVersion ✗ \(error.localizedDescription)", level: .error)
|
||
}
|
||
}
|
||
|
||
private func runBind() async {
|
||
isBusy = true
|
||
defer { isBusy = false }
|
||
log("→ bind(\(userId))")
|
||
do {
|
||
let result = try await sdk.bind(userId: userId)
|
||
log("bind ✓ sn=\(result.sn) contents=\(result.contents.count)", level: .success)
|
||
deviceFiles = result.contents
|
||
} catch {
|
||
log("bind ✗ \(error.localizedDescription)", level: .error)
|
||
}
|
||
}
|
||
|
||
private func runUnbind() async {
|
||
isBusy = true
|
||
defer { isBusy = false }
|
||
log("→ unbind(\(userId))")
|
||
do {
|
||
_ = try await sdk.unbind(userId: userId)
|
||
deviceFiles = []
|
||
log("unbind ✓", level: .success)
|
||
} catch {
|
||
log("unbind ✗ \(error.localizedDescription)", level: .error)
|
||
}
|
||
}
|
||
|
||
private func runConvertAndTransfer() async {
|
||
isBusy = true
|
||
defer { isBusy = false }
|
||
do {
|
||
// 1. Convert
|
||
log("→ AniConverter.convert")
|
||
let aniUrl = try await AniConverter.convert(videoUrl: videoUrl)
|
||
log("ani url: \(aniUrl)", level: .success)
|
||
|
||
// 2. HEAD request to get ani file size
|
||
log("→ HEAD \(aniUrl)")
|
||
let aniSize = try await getFileSize(url: aniUrl)
|
||
log("ani size: \(aniSize) bytes")
|
||
|
||
// 3. key = source video full URL
|
||
let key = videoUrl
|
||
log("key: \(key)")
|
||
|
||
// 4. prepareTransfer
|
||
log("→ prepareTransfer")
|
||
let prepareResult = try await sdk.prepareTransfer(key: key, size: aniSize)
|
||
log("prepareTransfer → status=\(prepareResult.status)", level: .success)
|
||
|
||
guard prepareResult.status == "ready" else {
|
||
log("device not ready: \(prepareResult.status)", level: .error)
|
||
return
|
||
}
|
||
|
||
// 5. transferFile
|
||
log("→ transferFile")
|
||
try await sdk.transferFile(fileUri: aniUrl)
|
||
log("transferFile ✓", level: .success)
|
||
} catch {
|
||
log("transfer failed: \(error.localizedDescription)", level: .error)
|
||
}
|
||
}
|
||
|
||
private func runTransferAniDirect() async {
|
||
isBusy = true
|
||
defer { isBusy = false }
|
||
do {
|
||
let aniUrl = aniUrlDirect.trimmingCharacters(in: .whitespacesAndNewlines)
|
||
guard !aniUrl.isEmpty else { return }
|
||
|
||
// 1) 获取 ani 文件大小（优先 HEAD，失败则直读数据长度）
|
||
log("→ HEAD \(aniUrl)")
|
||
var aniSize: Int = 0
|
||
do {
|
||
aniSize = try await getFileSize(url: aniUrl)
|
||
} catch {
|
||
aniSize = 0
|
||
}
|
||
if aniSize <= 0, let url = URL(string: aniUrl) {
|
||
log("HEAD 无法获取大小，回退为直接下载计算")
|
||
let (data, response) = try await URLSession.shared.data(from: url)
|
||
if let http = response as? HTTPURLResponse, (200...299).contains(http.statusCode) {
|
||
aniSize = data.count
|
||
} else {
|
||
throw AniConverterError(message: "下载 ani 失败")
|
||
}
|
||
}
|
||
log("ani size: \(aniSize) bytes")
|
||
|
||
// 2) 使用 aniUrl 作为 key 进行 prepare
|
||
let key = aniUrl
|
||
log("key: \(key)")
|
||
log("→ prepareTransfer")
|
||
let prepareResult = try await sdk.prepareTransfer(key: key, size: aniSize)
|
||
log("prepareTransfer → status=\(prepareResult.status)", level: .success)
|
||
|
||
guard prepareResult.status == "ready" else {
|
||
log("device not ready: \(prepareResult.status)", level: .error)
|
||
return
|
||
}
|
||
|
||
// 3) 传输 ANI 文件
|
||
log("→ transferFile (ANI)")
|
||
try await sdk.transferFile(fileUri: aniUrl, commandType: .transferAniVideo)
|
||
log("transferFile ✓", level: .success)
|
||
} catch {
|
||
log("transfer failed: \(error.localizedDescription)", level: .error)
|
||
}
|
||
}
|
||
|
||
private func runDeleteFile(_ rawKey: String) async {
|
||
isBusy = true
|
||
defer { isBusy = false }
|
||
log("→ deleteFile(\(rawKey))")
|
||
do {
|
||
_ = try await sdk.deleteFile(key: rawKey)
|
||
log("deleteFile ✓", level: .success)
|
||
deviceFiles.removeAll { $0 == rawKey }
|
||
} catch {
|
||
log("deleteFile ✗ \(error.localizedDescription)", level: .error)
|
||
}
|
||
}
|
||
|
||
private func runFetchFirmwareInfo() async {
|
||
guard let brand = sdk.deviceInfo?.brand, !brand.isEmpty else {
|
||
firmwareError = "No device brand"
|
||
return
|
||
}
|
||
firmwareLoading = true
|
||
firmwareError = nil
|
||
defer { firmwareLoading = false }
|
||
log("→ fetch firmware info for \(brand)")
|
||
do {
|
||
let info = try await FirmwareUpdateService.fetchLatest(brand: brand)
|
||
firmwareInfo = info
|
||
log("firmware latest: \(info.version)", level: .success)
|
||
} catch {
|
||
firmwareError = error.localizedDescription
|
||
log("firmware info ✗ \(error.localizedDescription)", level: .error)
|
||
}
|
||
}
|
||
|
||
private func runUpgradeFirmware() async {
|
||
guard let url = firmwareInfo?.fileUrl, !url.isEmpty else { return }
|
||
isBusy = true
|
||
defer { isBusy = false }
|
||
log("→ OTA transfer")
|
||
do {
|
||
try await sdk.transferFile(fileUri: url, commandType: .otaPackage)
|
||
log("OTA ✓", level: .success)
|
||
} catch {
|
||
log("OTA ✗ \(error.localizedDescription)", level: .error)
|
||
}
|
||
}
|
||
|
||
private func getFileSize(url: String) async throws -> Int {
|
||
guard let fileUrl = URL(string: url) else {
|
||
throw AniConverterError(message: "Invalid URL: \(url)")
|
||
}
|
||
var request = URLRequest(url: fileUrl)
|
||
request.httpMethod = "HEAD"
|
||
let (_, response) = try await URLSession.shared.data(for: request)
|
||
guard let http = response as? HTTPURLResponse else {
|
||
throw AniConverterError(message: "Invalid response")
|
||
}
|
||
return Int(http.expectedContentLength)
|
||
}
|
||
}
|