wehub-resource-sync
911 lines
31 KiB
Swift
911 lines
31 KiB
Swift
import AppKit
|
||
import SwiftUI
|
||
import MacToolsPluginKit
|
||
|
||
struct DeviceBatteryComponentView: View {
|
||
@ObservedObject var viewModel: DeviceBatteryViewModel
|
||
@ObservedObject var store: DeviceBatteryStore
|
||
let localization: PluginLocalization
|
||
let openSettings: () -> Void
|
||
|
||
var body: some View {
|
||
Group {
|
||
if visibleItems.isEmpty {
|
||
emptyState
|
||
} else {
|
||
switch store.layoutMode {
|
||
case .grid:
|
||
DeviceBatteryListCard(
|
||
items: Array(visibleItems.prefix(DeviceBatteryLayout.maximumListItems)),
|
||
totalCount: visibleItems.count,
|
||
localization: localization
|
||
)
|
||
case .list:
|
||
DeviceBatteryGaugeGrid(
|
||
items: Array(visibleItems.prefix(DeviceBatteryLayout.maximumGaugeItems)),
|
||
totalCount: visibleItems.count,
|
||
localization: localization
|
||
)
|
||
}
|
||
}
|
||
}
|
||
.frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .top)
|
||
}
|
||
|
||
private var visibleItems: [DeviceBatteryItem] {
|
||
viewModel.snapshot.visibleItems
|
||
}
|
||
|
||
private var emptyState: some View {
|
||
VStack(spacing: 8) {
|
||
Image(systemName: viewModel.snapshot.accessState.isError ? "exclamationmark.triangle" : "battery.0percent")
|
||
.font(.system(size: 24, weight: .semibold))
|
||
.symbolRenderingMode(.hierarchical)
|
||
.foregroundStyle(viewModel.snapshot.accessState.isError ? Color(nsColor: .systemOrange) : Color.secondary)
|
||
|
||
Text(emptyTitle)
|
||
.font(.system(size: 13, weight: .semibold))
|
||
.lineLimit(1)
|
||
.minimumScaleFactor(0.8)
|
||
|
||
Text(emptySubtitle)
|
||
.font(.system(size: 10, weight: .medium))
|
||
.foregroundStyle(.secondary)
|
||
.multilineTextAlignment(.center)
|
||
.lineLimit(2)
|
||
.fixedSize(horizontal: false, vertical: true)
|
||
|
||
if viewModel.snapshot.accessState == .permissionDenied {
|
||
Button(action: openSettings) {
|
||
Label(
|
||
localization.string("empty.openSettings", defaultValue: "打开系统设置"),
|
||
systemImage: "gearshape"
|
||
)
|
||
.font(.system(size: 11, weight: .semibold))
|
||
}
|
||
.buttonStyle(.bordered)
|
||
.controlSize(.small)
|
||
}
|
||
}
|
||
.padding(12)
|
||
.frame(maxWidth: .infinity)
|
||
.frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .top)
|
||
.background(DeviceBatteryCardBackground(cornerRadius: DeviceBatteryLayout.cornerRadius))
|
||
}
|
||
|
||
private var emptyTitle: String {
|
||
switch viewModel.snapshot.accessState {
|
||
case .permissionDenied:
|
||
return localization.string("empty.title.permissionDenied", defaultValue: "需要输入监控权限")
|
||
case .scanning:
|
||
return localization.string("empty.title.scanning", defaultValue: "正在读取电量")
|
||
case .failed:
|
||
return localization.string("empty.title.failed", defaultValue: "读取失败")
|
||
case .idle, .ready, .noDevices:
|
||
return localization.string("empty.title.noDevices", defaultValue: "暂无设备电量")
|
||
}
|
||
}
|
||
|
||
private var emptySubtitle: String {
|
||
switch viewModel.snapshot.accessState {
|
||
case .permissionDenied:
|
||
return localization.string("empty.subtitle.permissionDenied", defaultValue: "授权后可读取厂商 HID 鼠标")
|
||
case .failed(let message):
|
||
return message
|
||
case .scanning:
|
||
return localization.string("empty.subtitle.scanning", defaultValue: "正在查询系统电源与蓝牙设备")
|
||
case .idle, .ready, .noDevices:
|
||
return localization.string("empty.subtitle.noDevices", defaultValue: "连接蓝牙设备或厂商 HID 鼠标")
|
||
}
|
||
}
|
||
}
|
||
|
||
enum DeviceBatteryComponentLayout {
|
||
static let width = 4
|
||
static let cornerRadius: CGFloat = PluginComponentPanelLayoutMetrics.cardCornerRadius
|
||
static let horizontalPadding: CGFloat = 12
|
||
static let rowHeight: CGFloat = 34
|
||
static let overflowHeight: CGFloat = 20
|
||
static let rowIconWidth: CGFloat = 26
|
||
static let percentWidth: CGFloat = 38
|
||
static let batteryWidth: CGFloat = 23
|
||
static let cardVerticalPadding: CGFloat = 6
|
||
static let gaugeHorizontalPadding: CGFloat = 12
|
||
static let gaugeVerticalPadding: CGFloat = 10
|
||
static let maximumListItems = 6
|
||
static let maximumGaugeItems = 8
|
||
static let ringSpan: CGFloat = 0.78
|
||
static let ringRotation: Double = 129.6
|
||
static let ringTrackLineWidthScale: CGFloat = 1.15
|
||
static let poweredRingLineWidthScale: CGFloat = 1.38
|
||
|
||
static func contentHeight(mode: DeviceBatteryLayoutMode, visibleItemCount: Int) -> CGFloat {
|
||
guard visibleItemCount > 0 else {
|
||
return 116
|
||
}
|
||
|
||
switch mode {
|
||
case .grid:
|
||
return listCardHeight(totalCount: visibleItemCount)
|
||
case .list:
|
||
return gaugeCardHeight(totalCount: visibleItemCount)
|
||
}
|
||
}
|
||
|
||
static func spanHeight(
|
||
mode: DeviceBatteryLayoutMode,
|
||
visibleItemCount: Int,
|
||
metrics: PluginComponentPanelLayoutMetrics = .default
|
||
) -> Int {
|
||
metrics.heightSpan(
|
||
fittingContentHeight: contentHeight(
|
||
mode: mode,
|
||
visibleItemCount: visibleItemCount
|
||
)
|
||
)
|
||
}
|
||
|
||
static func listCardHeight(totalCount: Int) -> CGFloat {
|
||
let displayCount = min(max(totalCount, 1), maximumListItems)
|
||
return cardVerticalPadding * 2
|
||
+ CGFloat(displayCount) * rowHeight
|
||
+ CGFloat(max(displayCount - 1, 0))
|
||
+ overflowHeightIfNeeded(totalCount: totalCount, displayedCount: displayCount)
|
||
}
|
||
|
||
static func gaugeCardHeight(totalCount: Int) -> CGFloat {
|
||
let displayCount = min(max(totalCount, 1), maximumGaugeItems)
|
||
let tileSize = gaugeTileSize(for: displayCount)
|
||
let rows = gaugeRowCount(totalCount: totalCount)
|
||
let rowSpacing = gaugeRowSpacing(for: displayCount)
|
||
return gaugeVerticalPadding * 2
|
||
+ CGFloat(rows) * (tileSize + gaugePercentHeight)
|
||
+ CGFloat(max(rows - 1, 0)) * rowSpacing
|
||
}
|
||
|
||
static func gaugeColumnCount(for itemCount: Int) -> Int {
|
||
switch itemCount {
|
||
case 0...1:
|
||
return 1
|
||
case 2:
|
||
return 2
|
||
case 3:
|
||
return 3
|
||
default:
|
||
return 4
|
||
}
|
||
}
|
||
|
||
static func gaugeRowCount(totalCount: Int) -> Int {
|
||
let displayCount = min(max(totalCount, 1), maximumGaugeItems)
|
||
let cellCount = displayCount + (totalCount > displayCount ? 1 : 0)
|
||
let columns = gaugeColumnCount(for: displayCount)
|
||
return Int(ceil(Double(cellCount) / Double(columns)))
|
||
}
|
||
|
||
static func gaugeTileSize(for itemCount: Int) -> CGFloat {
|
||
switch itemCount {
|
||
case 0...2:
|
||
return 66
|
||
case 3...4:
|
||
return 58
|
||
default:
|
||
return 50
|
||
}
|
||
}
|
||
|
||
static func gaugeLineWidth(for tileSize: CGFloat) -> CGFloat {
|
||
max(4, tileSize * 0.078)
|
||
}
|
||
|
||
static let gaugePercentHeight: CGFloat = 20
|
||
|
||
static func gaugeRowSpacing(for itemCount: Int) -> CGFloat {
|
||
itemCount > 4 ? 8 : 6
|
||
}
|
||
|
||
static func overflowHeightIfNeeded(totalCount: Int, displayedCount: Int) -> CGFloat {
|
||
totalCount > displayedCount ? overflowHeight + 1 : 0
|
||
}
|
||
}
|
||
|
||
private typealias DeviceBatteryLayout = DeviceBatteryComponentLayout
|
||
|
||
private struct DeviceBatteryListCard: View {
|
||
let items: [DeviceBatteryItem]
|
||
let totalCount: Int
|
||
let localization: PluginLocalization
|
||
|
||
var body: some View {
|
||
VStack(spacing: 0) {
|
||
ForEach(Array(items.enumerated()), id: \.element.id) { index, item in
|
||
DeviceBatteryNativeRow(
|
||
item: item,
|
||
rowHeight: DeviceBatteryLayout.rowHeight,
|
||
showsDetail: false,
|
||
localization: localization
|
||
)
|
||
|
||
if index < items.count - 1 {
|
||
DeviceBatteryDivider()
|
||
}
|
||
}
|
||
|
||
if totalCount > items.count {
|
||
DeviceBatteryDivider()
|
||
DeviceBatteryOverflowRow(count: totalCount - items.count, localization: localization)
|
||
}
|
||
}
|
||
.padding(.vertical, DeviceBatteryLayout.cardVerticalPadding)
|
||
.frame(maxWidth: .infinity)
|
||
.frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .top)
|
||
.background(DeviceBatteryCardBackground(cornerRadius: DeviceBatteryLayout.cornerRadius))
|
||
}
|
||
}
|
||
|
||
private struct DeviceBatteryGaugeGrid: View {
|
||
let items: [DeviceBatteryItem]
|
||
let totalCount: Int
|
||
let localization: PluginLocalization
|
||
|
||
var body: some View {
|
||
Group {
|
||
LazyVGrid(columns: columns, spacing: rowSpacing) {
|
||
ForEach(items) { item in
|
||
DeviceBatteryGaugeTile(
|
||
item: item,
|
||
tileSize: tileSize,
|
||
lineWidth: DeviceBatteryLayout.gaugeLineWidth(for: tileSize),
|
||
localization: localization
|
||
)
|
||
.frame(maxWidth: .infinity)
|
||
}
|
||
|
||
if totalCount > items.count {
|
||
Text("+\(totalCount - items.count)")
|
||
.font(.caption.weight(.semibold))
|
||
.foregroundStyle(.secondary)
|
||
.frame(width: tileSize, height: tileSize + DeviceBatteryLayout.gaugePercentHeight)
|
||
}
|
||
}
|
||
.padding(.horizontal, DeviceBatteryLayout.gaugeHorizontalPadding)
|
||
.padding(.vertical, DeviceBatteryLayout.gaugeVerticalPadding)
|
||
.frame(maxWidth: .infinity)
|
||
}
|
||
.frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .top)
|
||
.background(DeviceBatteryCardBackground(cornerRadius: DeviceBatteryLayout.cornerRadius))
|
||
}
|
||
|
||
private var tileSize: CGFloat {
|
||
DeviceBatteryLayout.gaugeTileSize(for: items.count)
|
||
}
|
||
|
||
private var rowSpacing: CGFloat {
|
||
DeviceBatteryLayout.gaugeRowSpacing(for: items.count)
|
||
}
|
||
|
||
private var columns: [GridItem] {
|
||
Array(
|
||
repeating: GridItem(.flexible(minimum: tileSize), spacing: items.count > 4 ? 6 : 8),
|
||
count: DeviceBatteryLayout.gaugeColumnCount(for: items.count)
|
||
)
|
||
}
|
||
}
|
||
|
||
private struct DeviceBatteryGaugeTile: View {
|
||
let item: DeviceBatteryItem
|
||
let tileSize: CGFloat
|
||
let lineWidth: CGFloat
|
||
let localization: PluginLocalization
|
||
|
||
var body: some View {
|
||
VStack(spacing: 2) {
|
||
ZStack {
|
||
DeviceBatteryRing(
|
||
item: item,
|
||
size: tileSize,
|
||
lineWidth: lineWidth,
|
||
localization: localization
|
||
)
|
||
|
||
Image(systemName: deviceSymbolName(for: item))
|
||
.font(.system(size: tileSize * 0.32, weight: .regular))
|
||
.symbolRenderingMode(.hierarchical)
|
||
.foregroundStyle(iconTint)
|
||
.frame(width: tileSize * 0.54, height: tileSize * 0.48)
|
||
}
|
||
.frame(width: tileSize, height: tileSize)
|
||
.overlay {
|
||
if chargingSymbolName(for: item) != nil {
|
||
let badgeSize = max(14, tileSize * 0.24)
|
||
DeviceBatteryChargingBadge(
|
||
systemName: "bolt.fill",
|
||
color: batteryTint(for: item),
|
||
size: badgeSize
|
||
)
|
||
.position(x: tileSize / 2, y: chargingBadgeCenterY)
|
||
}
|
||
}
|
||
|
||
Text(DeviceBatteryFormatter.percent(item.clampedLevel))
|
||
.font(.system(size: max(10, tileSize * 0.18), weight: .regular, design: .rounded))
|
||
.foregroundStyle(.primary)
|
||
.monospacedDigit()
|
||
.lineLimit(1)
|
||
.minimumScaleFactor(0.7)
|
||
}
|
||
.frame(width: tileSize, height: tileSize + DeviceBatteryLayout.gaugePercentHeight)
|
||
.compositingGroup()
|
||
.help(helpText(for: item, localization: localization))
|
||
}
|
||
|
||
private var iconTint: Color {
|
||
chargingSymbolName(for: item) == nil
|
||
? Color.primary.opacity(0.58)
|
||
: batteryTint(for: item).opacity(0.84)
|
||
}
|
||
|
||
private var chargingBadgeCenterY: CGFloat {
|
||
ringPathInset
|
||
}
|
||
|
||
private var ringPathInset: CGFloat {
|
||
lineWidth * DeviceBatteryLayout.poweredRingLineWidthScale / 2
|
||
}
|
||
}
|
||
|
||
private struct DeviceBatteryChargingBadge: View {
|
||
let systemName: String
|
||
let color: Color
|
||
let size: CGFloat
|
||
|
||
var body: some View {
|
||
ZStack {
|
||
Circle()
|
||
.fill(Color.white)
|
||
|
||
Image(systemName: systemName)
|
||
.font(.system(size: max(7.2, size * 0.54), weight: .black))
|
||
.foregroundStyle(color)
|
||
}
|
||
.frame(width: size, height: size)
|
||
.accessibilityHidden(true)
|
||
}
|
||
}
|
||
|
||
private struct DeviceBatteryRing: View {
|
||
let item: DeviceBatteryItem
|
||
let size: CGFloat
|
||
let lineWidth: CGFloat
|
||
var localization: PluginLocalization = PluginLocalization(bundle: .main)
|
||
|
||
var body: some View {
|
||
ZStack {
|
||
Circle()
|
||
.inset(by: ringPathInset)
|
||
.trim(from: 0, to: DeviceBatteryLayout.ringSpan)
|
||
.stroke(
|
||
Color.primary.opacity(0.12),
|
||
style: StrokeStyle(
|
||
lineWidth: lineWidth * DeviceBatteryLayout.ringTrackLineWidthScale,
|
||
lineCap: .round,
|
||
lineJoin: .round
|
||
)
|
||
)
|
||
|
||
if showsPoweredOverlay {
|
||
Circle()
|
||
.inset(by: ringPathInset)
|
||
.trim(from: 0, to: DeviceBatteryLayout.ringSpan)
|
||
.stroke(
|
||
batteryTint(for: item).opacity(0.12),
|
||
style: StrokeStyle(
|
||
lineWidth: lineWidth * DeviceBatteryLayout.poweredRingLineWidthScale,
|
||
lineCap: .round,
|
||
lineJoin: .round
|
||
)
|
||
)
|
||
|
||
if progressSpan > 0.002, progress < 0.995 {
|
||
Circle()
|
||
.inset(by: ringPathInset)
|
||
.trim(from: max(progressSpan - 0.002, 0), to: max(progressSpan - 0.0004, 0))
|
||
.stroke(
|
||
batteryTint(for: item),
|
||
style: StrokeStyle(lineWidth: lineWidth, lineCap: .round, lineJoin: .round)
|
||
)
|
||
.shadow(color: batteryTint(for: item).opacity(0.32), radius: lineWidth * 0.7)
|
||
.clipShape(
|
||
Circle()
|
||
.inset(by: ringPathInset)
|
||
.trim(from: 0, to: DeviceBatteryLayout.ringSpan)
|
||
.stroke(style: StrokeStyle(lineWidth: lineWidth * 1.4, lineCap: .round, lineJoin: .round))
|
||
)
|
||
}
|
||
}
|
||
|
||
Circle()
|
||
.inset(by: ringPathInset)
|
||
.trim(from: 0, to: progressSpan)
|
||
.stroke(
|
||
batteryTint(for: item),
|
||
style: StrokeStyle(lineWidth: lineWidth, lineCap: .round, lineJoin: .round)
|
||
)
|
||
}
|
||
.rotationEffect(.degrees(DeviceBatteryLayout.ringRotation))
|
||
.frame(width: size, height: size)
|
||
.accessibilityLabel(
|
||
localization.format(
|
||
"accessibility.ring",
|
||
defaultValue: "%@，%@",
|
||
item.name,
|
||
DeviceBatteryFormatter.percent(item.clampedLevel)
|
||
)
|
||
)
|
||
}
|
||
|
||
private var progress: CGFloat {
|
||
CGFloat(item.clampedLevel ?? 0) / 100
|
||
}
|
||
|
||
private var progressSpan: CGFloat {
|
||
DeviceBatteryLayout.ringSpan * progress
|
||
}
|
||
|
||
private var showsPoweredOverlay: Bool {
|
||
chargingSymbolName(for: item) != nil
|
||
}
|
||
|
||
private var ringPathInset: CGFloat {
|
||
lineWidth * DeviceBatteryLayout.poweredRingLineWidthScale / 2
|
||
}
|
||
}
|
||
|
||
private struct DeviceBatteryDivider: View {
|
||
var body: some View {
|
||
Divider()
|
||
.padding(.leading, DeviceBatteryLayout.horizontalPadding + DeviceBatteryLayout.rowIconWidth + 10)
|
||
.padding(.trailing, DeviceBatteryLayout.horizontalPadding)
|
||
}
|
||
}
|
||
|
||
private struct DeviceBatteryOverflowRow: View {
|
||
let count: Int
|
||
let localization: PluginLocalization
|
||
|
||
var body: some View {
|
||
Text(localization.format("overflow.moreDevices", defaultValue: "还有 %d 台设备", count))
|
||
.font(.caption2.weight(.medium))
|
||
.foregroundStyle(.tertiary)
|
||
.frame(maxWidth: .infinity)
|
||
.frame(height: DeviceBatteryLayout.overflowHeight)
|
||
}
|
||
}
|
||
|
||
private struct DeviceBatteryNativeRow: View {
|
||
let item: DeviceBatteryItem
|
||
let rowHeight: CGFloat
|
||
var showsDetail = false
|
||
var compact = false
|
||
var prominent = false
|
||
var localization: PluginLocalization = PluginLocalization(bundle: .main)
|
||
|
||
var body: some View {
|
||
HStack(spacing: compact ? 8 : 10) {
|
||
Image(systemName: deviceSymbolName(for: item))
|
||
.font(.system(size: iconSize, weight: .regular))
|
||
.symbolRenderingMode(.hierarchical)
|
||
.foregroundStyle(Color.primary.opacity(iconOpacity))
|
||
.frame(width: DeviceBatteryLayout.rowIconWidth, height: rowHeight)
|
||
|
||
VStack(alignment: .leading, spacing: showsDetail ? 2 : 0) {
|
||
Text(item.name)
|
||
.font(titleFont)
|
||
.foregroundStyle(.primary)
|
||
.lineLimit(1)
|
||
.truncationMode(.tail)
|
||
.minimumScaleFactor(0.72)
|
||
|
||
if showsDetail {
|
||
Text(deviceDetailText(for: item, localization: localization))
|
||
.font(.caption2.weight(.medium))
|
||
.foregroundStyle(.tertiary)
|
||
.lineLimit(1)
|
||
.truncationMode(.tail)
|
||
.minimumScaleFactor(0.7)
|
||
}
|
||
}
|
||
.frame(maxWidth: .infinity, alignment: .leading)
|
||
.layoutPriority(1)
|
||
|
||
Text(DeviceBatteryFormatter.percent(item.clampedLevel))
|
||
.font(percentFont)
|
||
.foregroundStyle(item.clampedLevel ?? 100 <= 10 ? Color(nsColor: .systemRed) : .primary)
|
||
.monospacedDigit()
|
||
.lineLimit(1)
|
||
.minimumScaleFactor(0.75)
|
||
.frame(width: DeviceBatteryLayout.percentWidth, alignment: .trailing)
|
||
|
||
DeviceBatterySystemBattery(item: item)
|
||
.frame(width: DeviceBatteryLayout.batteryWidth, height: 14)
|
||
}
|
||
.padding(.horizontal, DeviceBatteryLayout.horizontalPadding)
|
||
.frame(height: rowHeight)
|
||
.help(helpText(for: item, localization: localization))
|
||
}
|
||
|
||
private var titleFont: Font {
|
||
if prominent {
|
||
return .body.weight(.semibold)
|
||
}
|
||
return compact ? .caption.weight(.medium) : .subheadline.weight(.medium)
|
||
}
|
||
|
||
private var percentFont: Font {
|
||
if prominent {
|
||
return .subheadline
|
||
}
|
||
return compact
|
||
? .caption2
|
||
: .caption
|
||
}
|
||
|
||
private var iconSize: CGFloat {
|
||
if prominent {
|
||
return 21
|
||
}
|
||
return compact ? 15 : 17
|
||
}
|
||
|
||
private var iconOpacity: Double {
|
||
prominent ? 0.64 : 0.56
|
||
}
|
||
}
|
||
|
||
private struct DeviceBatterySystemBattery: View {
|
||
let item: DeviceBatteryItem
|
||
|
||
var body: some View {
|
||
HStack(spacing: 1) {
|
||
ZStack(alignment: .leading) {
|
||
RoundedRectangle(cornerRadius: 1.9, style: .continuous)
|
||
.stroke(Color.primary.opacity(0.30), lineWidth: 0.85)
|
||
.frame(width: 18, height: 8.2)
|
||
|
||
RoundedRectangle(cornerRadius: 1.2, style: .continuous)
|
||
.fill(batteryTint(for: item))
|
||
.frame(width: fillWidth, height: 4.8)
|
||
.padding(.leading, 1.9)
|
||
.opacity(item.clampedLevel == nil ? 0.18 : 0.82)
|
||
|
||
if chargingSymbolName(for: item) != nil {
|
||
Image(systemName: "bolt.fill")
|
||
.font(.system(size: 5.1, weight: .black))
|
||
.symbolRenderingMode(.hierarchical)
|
||
.foregroundStyle(.white)
|
||
.frame(width: 18, height: 8.2)
|
||
}
|
||
}
|
||
|
||
RoundedRectangle(cornerRadius: 0.8, style: .continuous)
|
||
.fill(Color.primary.opacity(0.30))
|
||
.frame(width: 1.3, height: 3.6)
|
||
}
|
||
.accessibilityLabel(DeviceBatteryFormatter.percent(item.clampedLevel))
|
||
}
|
||
|
||
private var fillWidth: CGFloat {
|
||
guard let level = item.clampedLevel else {
|
||
return 3
|
||
}
|
||
|
||
return max(2.8, 14.2 * CGFloat(level) / 100)
|
||
}
|
||
}
|
||
|
||
private struct DeviceBatteryCardBackground: View {
|
||
let cornerRadius: CGFloat
|
||
|
||
var body: some View {
|
||
RoundedRectangle(cornerRadius: cornerRadius, style: .continuous)
|
||
.fill(Color.primary.opacity(0.045))
|
||
}
|
||
}
|
||
|
||
private func batteryTint(for item: DeviceBatteryItem?) -> Color {
|
||
guard let item else {
|
||
return Color(nsColor: .systemGreen)
|
||
}
|
||
|
||
if item.chargeState == .charging || item.chargeState == .charged {
|
||
return Color(nsColor: .systemGreen)
|
||
}
|
||
|
||
guard let level = item.clampedLevel else {
|
||
return Color(nsColor: .systemBlue)
|
||
}
|
||
|
||
if level <= 20 {
|
||
return Color(nsColor: .systemRed)
|
||
}
|
||
if level <= 35 {
|
||
return Color(nsColor: .systemOrange)
|
||
}
|
||
return Color(nsColor: .systemGreen)
|
||
}
|
||
|
||
private func chargingSymbolName(for item: DeviceBatteryItem) -> String? {
|
||
switch item.chargeState {
|
||
case .charging, .charged:
|
||
return "bolt.fill"
|
||
case .plugged:
|
||
return "powerplug.fill"
|
||
case .unknown, .normal, .invalid:
|
||
return nil
|
||
}
|
||
}
|
||
|
||
private func batterySymbolName(for item: DeviceBatteryItem) -> String {
|
||
if item.chargeState == .charging || item.chargeState == .charged || item.chargeState == .plugged {
|
||
return "battery.100percent.bolt"
|
||
}
|
||
|
||
guard let level = item.clampedLevel else {
|
||
return "battery.0percent"
|
||
}
|
||
|
||
switch level {
|
||
case 76...100:
|
||
return "battery.100percent"
|
||
case 51...75:
|
||
return "battery.75percent"
|
||
case 26...50:
|
||
return "battery.50percent"
|
||
case 11...25:
|
||
return "battery.25percent"
|
||
default:
|
||
return "battery.0percent"
|
||
}
|
||
}
|
||
|
||
private func deviceDetailText(
|
||
for item: DeviceBatteryItem,
|
||
localization: PluginLocalization = PluginLocalization(bundle: .main)
|
||
) -> String {
|
||
if let detail = item.detail, !detail.isEmpty {
|
||
return detail
|
||
}
|
||
if let model = item.model, !model.isEmpty, model != item.name {
|
||
return model
|
||
}
|
||
return item.chargeState == .normal
|
||
? localization.string("deviceDetail.connected", defaultValue: "已连接")
|
||
: item.chargeState.title(localization: localization)
|
||
}
|
||
|
||
func deviceSymbolName(for item: DeviceBatteryItem) -> String {
|
||
let haystack = [
|
||
item.name,
|
||
item.model,
|
||
item.detail,
|
||
item.parentName,
|
||
item.kind.title()
|
||
]
|
||
.compactMap { $0?.lowercased() }
|
||
.joined(separator: " ")
|
||
|
||
switch item.kind {
|
||
case .internalBattery:
|
||
if containsAny(haystack, ["macbook", "mac book", "book"]) {
|
||
return "macbook"
|
||
}
|
||
if containsAny(haystack, ["mac mini", "macmini", "mini"]) {
|
||
return "macmini"
|
||
}
|
||
if containsAny(haystack, ["imac"]) {
|
||
return "desktopcomputer"
|
||
}
|
||
return "desktopcomputer.and.macbook"
|
||
case .phone:
|
||
return "iphone.gen2"
|
||
case .tablet:
|
||
return "ipad"
|
||
case .mediaPlayer:
|
||
return "ipodtouch"
|
||
case .watch:
|
||
return "applewatch"
|
||
case .spatialComputer:
|
||
return "visionpro"
|
||
case .rapooMouse:
|
||
return "computermouse.fill"
|
||
case .airPodsPart:
|
||
let ownName = item.name.lowercased()
|
||
if ownName.contains("case") || ownName.contains("充电盒") {
|
||
return airPodsSymbolName(in: haystack, part: .case)
|
||
}
|
||
if ownName.contains("左耳") || ownName.contains("left") || ownName.contains("🄻") {
|
||
return airPodsSymbolName(in: haystack, part: .left)
|
||
}
|
||
if ownName.contains("右耳") || ownName.contains("right") || ownName.contains("🅁") {
|
||
return airPodsSymbolName(in: haystack, part: .right)
|
||
}
|
||
return airPodsSymbolName(in: haystack, part: .all)
|
||
case .bluetooth, .magicAccessory, .other:
|
||
if containsAny(haystack, ["iphone", "phone", "mobile phone", "手机"]) {
|
||
return "iphone.gen2"
|
||
}
|
||
if containsAny(haystack, ["ipad", "tablet", "平板"]) {
|
||
return "ipad"
|
||
}
|
||
if containsAny(haystack, ["watch", "手表"]) {
|
||
return "applewatch"
|
||
}
|
||
if haystack.contains("vision") {
|
||
return "visionpro"
|
||
}
|
||
if containsAny(haystack, ["macbook", "mac book", "notebook", "laptop"]) {
|
||
return "macbook"
|
||
}
|
||
if containsAny(haystack, ["mac mini", "macmini"]) {
|
||
return "macmini"
|
||
}
|
||
if containsAny(haystack, ["imac", "desktop computer"]) {
|
||
return "desktopcomputer"
|
||
}
|
||
if containsAny(haystack, ["magic mouse", "magicmouse"]) {
|
||
return "magicmouse.fill"
|
||
}
|
||
if containsAny(haystack, ["mouse", "pointing", "鼠标", "mx anywhere", "mx master", "razer"]) {
|
||
return "computermouse.fill"
|
||
}
|
||
if containsAny(haystack, ["keyboard", "键盘", "hhkb", "niz"]) {
|
||
return "keyboard.fill"
|
||
}
|
||
if containsAny(haystack, ["trackpad", "touchpad", "触控板"]) {
|
||
return "rectangle.and.hand.point.up.left.fill"
|
||
}
|
||
if containsAny(haystack, ["airpods"]) {
|
||
return airPodsSymbolName(in: haystack, part: .all)
|
||
}
|
||
if containsAny(haystack, ["beats", "headphone", "headphones", "headset", "earbud", "earbuds", "耳机"]) {
|
||
return "headphones"
|
||
}
|
||
if containsAny(haystack, ["gamepad", "controller", "joystick", "手柄"]) {
|
||
return "gamecontroller.fill"
|
||
}
|
||
if containsAny(haystack, ["speaker", "音箱", "扬声器"]) {
|
||
return "hifispeaker.fill"
|
||
}
|
||
if containsAny(haystack, ["printer", "打印机"]) {
|
||
return "printer.fill"
|
||
}
|
||
if containsAny(haystack, ["camera", "摄像头", "相机"]) {
|
||
return "camera.fill"
|
||
}
|
||
return item.kind.iconName
|
||
}
|
||
}
|
||
|
||
private func containsAny(_ text: String, _ needles: [String]) -> Bool {
|
||
needles.contains { text.contains($0) }
|
||
}
|
||
|
||
private enum DeviceBatteryAirPodsPart {
|
||
case all
|
||
case left
|
||
case right
|
||
case `case`
|
||
}
|
||
|
||
private func airPodsSymbolName(
|
||
in haystack: String,
|
||
part: DeviceBatteryAirPodsPart
|
||
) -> String {
|
||
if haystack.contains("airpods max") {
|
||
return availableSystemSymbolName(["airpods.max", "airpodsmax"])
|
||
}
|
||
|
||
if isAirPodsPro(in: haystack) {
|
||
switch part {
|
||
case .all:
|
||
return "airpodspro"
|
||
case .left:
|
||
return "airpodpro.left"
|
||
case .right:
|
||
return "airpodpro.right"
|
||
case .case:
|
||
return "airpodspro.chargingcase.wireless"
|
||
}
|
||
}
|
||
|
||
if isAirPodsGeneration(4, in: haystack) {
|
||
switch part {
|
||
case .all:
|
||
return availableSystemSymbolName(["airpods.gen4", "airpods"])
|
||
case .left:
|
||
return availableSystemSymbolName(["airpods.gen4.left", "airpod.left"])
|
||
case .right:
|
||
return availableSystemSymbolName(["airpods.gen4.right", "airpod.right"])
|
||
case .case:
|
||
return availableSystemSymbolName(["airpods.gen4.chargingcase.wireless", "airpods.chargingcase"])
|
||
}
|
||
}
|
||
|
||
if isAirPodsGeneration(3, in: haystack) {
|
||
switch part {
|
||
case .all:
|
||
return availableSystemSymbolName(["airpods.gen3", "airpods"])
|
||
case .left:
|
||
return availableSystemSymbolName(["airpod.gen3.left", "airpod.left"])
|
||
case .right:
|
||
return availableSystemSymbolName(["airpod.gen3.right", "airpod.right"])
|
||
case .case:
|
||
return availableSystemSymbolName(["airpods.gen3.chargingcase.wireless", "airpods.chargingcase"])
|
||
}
|
||
}
|
||
|
||
switch part {
|
||
case .all:
|
||
return "airpods"
|
||
case .left:
|
||
return "airpod.left"
|
||
case .right:
|
||
return "airpod.right"
|
||
case .case:
|
||
return "airpods.chargingcase"
|
||
}
|
||
}
|
||
|
||
private func isAirPodsPro(in haystack: String) -> Bool {
|
||
haystack.contains("airpods pro") || haystack.contains("airpodspro")
|
||
}
|
||
|
||
private func isAirPodsGeneration(_ generation: Int, in haystack: String) -> Bool {
|
||
let compact = haystack.replacingOccurrences(of: " ", with: "")
|
||
return haystack.contains("airpods \(generation)")
|
||
|| haystack.contains("airpods gen\(generation)")
|
||
|| haystack.contains("airpods gen \(generation)")
|
||
|| haystack.contains("airpods.gen\(generation)")
|
||
|| compact.contains("airpods\(generation)")
|
||
|| compact.contains("第\(generation)代")
|
||
}
|
||
|
||
private func availableSystemSymbolName(_ candidates: [String]) -> String {
|
||
for candidate in candidates {
|
||
if NSImage(systemSymbolName: candidate, accessibilityDescription: nil) != nil {
|
||
return candidate
|
||
}
|
||
}
|
||
|
||
return candidates.last ?? "airpods"
|
||
}
|
||
|
||
private func helpText(
|
||
for item: DeviceBatteryItem,
|
||
localization: PluginLocalization = PluginLocalization(bundle: .main)
|
||
) -> String {
|
||
var lines = [
|
||
item.name,
|
||
localization.format(
|
||
"help.levelAndState",
|
||
defaultValue: "%@ · %@",
|
||
DeviceBatteryFormatter.percent(item.clampedLevel),
|
||
item.chargeState.title(localization: localization)
|
||
),
|
||
localization.format("help.source", defaultValue: "来源：%@", item.source)
|
||
]
|
||
if let parentName = item.parentName {
|
||
lines.append(localization.format("help.parent", defaultValue: "关联：%@", parentName))
|
||
}
|
||
if let lastUpdated = item.lastUpdated {
|
||
lines.append(
|
||
localization.format(
|
||
"help.updated",
|
||
defaultValue: "更新：%@",
|
||
DeviceBatteryFormatter.time(lastUpdated, localization: localization)
|
||
)
|
||
)
|
||
}
|
||
return lines.joined(separator: "\n")
|
||
}
|