Skip to content

Colota - Android GPS Location tracker

5.9 KB
Raw Blame
/**
 * Copyright (C) 2026 Max Dietrich
 * Licensed under the GNU AGPLv3. See LICENSE in the project root for details.
 */

import { formatTime, formatWhen, metersToInput, shortDistanceUnit } from "./geo"
import { t } from "../i18n/t"

export type BannerCondition = "permission" | "background" | "locationOff" | "battery"

export interface BannerInput {
  permissions: { location: boolean; background: boolean } | null
  locationEnabled: boolean
  isBatteryCritical: boolean
  tracking: boolean
}

export function pickBannerCondition({
  permissions,
  locationEnabled,
  isBatteryCritical,
  tracking
}: BannerInput): BannerCondition | null {
  if (permissions && !permissions.location) return "permission"
  if (permissions && tracking && !permissions.background) return "background"
  if (!locationEnabled) return "locationOff"
  if (isBatteryCritical && !tracking) return "battery"
  return null
}

export type StateIcon = "dashed" | "loader" | "circleDot" | "pause" | "alert"
export type StateTone = "secondary" | "primary" | "success" | "error"

export interface StateDescription {
  icon: StateIcon
  tone: StateTone
  label: string
  caption: string
}

export interface StateInput {
  tracking: boolean
  hasFix: boolean
  locationEnabled: boolean
  activeZoneName: string | null
  pauseReason: string | null
  activeProfileName: string | null
  coords: { accuracy: number; timestamp: number } | null
  lastKnown: { timestamp: number } | null
  stoppedByBattery: boolean
  now?: Date
}

function pauseCaption(zoneName: string, pauseReason: string | null): string {
  if (pauseReason === "wifi") return t("state.pause.wifi", { zone: zoneName })
  if (pauseReason === "motionless") return t("state.pause.motionless")
  return t("state.pause.zone")
}

export function describeState(input: StateInput): StateDescription {
  const { tracking, hasFix, locationEnabled, activeZoneName, pauseReason, activeProfileName, coords } = input

  if (!tracking) {
    if (input.stoppedByBattery) {
      return { icon: "alert", tone: "error", label: t("state.stopped"), caption: t("state.stoppedByBattery") }
    }
    return {
      icon: "dashed",
      tone: "secondary",
      label: t("state.ready"),
      caption: formatLastFix(input.lastKnown?.timestamp ?? null, input.now)
    }
  }

  if (activeZoneName) {
    return {
      icon: "pause",
      tone: "secondary",
      label: t("state.pausedIn", { zone: activeZoneName }),
      caption: pauseCaption(activeZoneName, pauseReason)
    }
  }

  if (!hasFix || !coords) {
    return {
      icon: "loader",
      tone: "primary",
      label: t("state.searching"),
      caption: locationEnabled ? t("state.noFixYet") : t("state.locationOff")
    }
  }

  const accuracy = Math.round(metersToInput(coords.accuracy))
  return {
    icon: "circleDot",
    tone: "success",
    label: activeProfileName ? t("state.trackingProfile", { profile: activeProfileName }) : t("state.tracking"),
    caption: `±${accuracy} ${shortDistanceUnit()} · ${formatTime(coords.timestamp)}`
  }
}

export function formatDuration(seconds: number): string {
  if (seconds >= 3600 && seconds % 3600 === 0) return `${seconds / 3600} ${t("unit.h")}`
  if (seconds >= 60 && seconds % 60 === 0) return `${seconds / 60} ${t("unit.min")}`
  return `${seconds} ${t("unit.s")}`
}

/** "Instant" for 0, the duration otherwise: the sync-interval rows and the profile editor's default. */
export function syncIntervalLabel(seconds: number): string {
  return seconds === 0 ? t("syncInterval.instant") : formatDuration(seconds)
}

export function formatInterval(seconds: number): string {
  return t("tracking.every", { duration: formatDuration(seconds) })
}

/** "Every 30 s after 2 m", or ", any movement" when no distance gates a fix. */
export function recordingSummary(intervalSeconds: number, distanceMeters: number): string {
  const duration = formatDuration(intervalSeconds)
  if (distanceMeters === 0) return t("tracking.recording.anyMovement", { duration })
  return t("tracking.recording.after", {
    duration,
    distance: `${metersToInput(distanceMeters)} ${shortDistanceUnit()}`
  })
}

/** "every 30 s after 2 m": the recording clause inside a sentence, where it does not open it. */
export function recordingPhrase(intervalSeconds: number, distanceMeters: number): string {
  const duration = formatDuration(intervalSeconds)
  if (distanceMeters === 0) return t("tracking.phrase.anyMovement", { duration })
  return t("tracking.phrase.after", {
    duration,
    distance: `${metersToInput(distanceMeters)} ${shortDistanceUnit()}`
  })
}

/** "syncs each fix" or "syncs every 5 min", lower case so a caption can carry it. */
export function syncSummary(syncIntervalSeconds: number): string {
  return syncIntervalSeconds === 0
    ? t("tracking.sync.eachFix")
    : t("tracking.sync.every", { duration: formatDuration(syncIntervalSeconds) })
}

/** The one line a preset row, the Custom row and the Settings row all print for a configuration. */
export function trackingSummary(
  intervalSeconds: number,
  distanceMeters: number,
  syncIntervalSeconds: number,
  isOfflineMode: boolean
): string {
  const recording = recordingSummary(intervalSeconds, distanceMeters)
  return isOfflineMode ? recording : `${recording} · ${syncSummary(syncIntervalSeconds)}`
}

export type IntervalLines = { label: string; caption: string }

export function intervalLines(
  intervalSeconds: number,
  syncIntervalSeconds: number,
  isOfflineMode: boolean
): IntervalLines {
  const caption = isOfflineMode
    ? t("dashboard.offlineMode")
    : syncIntervalSeconds === 0
      ? t("tracking.interval.instantSync")
      : t("tracking.interval.sync", { duration: formatDuration(syncIntervalSeconds) })
  return { label: formatInterval(intervalSeconds), caption }
}

export function formatLastFix(timestampSeconds: number | null, now: Date = new Date()): string {
  if (timestampSeconds === null) return t("state.noFixes")
  return t("state.lastFix", { when: formatWhen(timestampSeconds, now) })
}