Compare commits
7 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 KaraZajac
|
2ff63da9b5 | ||
|
KaraZajac
|
c9cafb3e67 | ||
|
KaraZajac
|
508430e1e3 | ||
|
KaraZajac
|
451376e497 | ||
|
KaraZajac
|
246c738ee4 | ||
|
KaraZajac
|
aa34a1c518 | ||
|
KaraZajac
|
87b1f0b887 |
@@ -1,51 +0,0 @@
|
||||
name: Build APK
|
||||
|
||||
on:
|
||||
push:
|
||||
tags:
|
||||
- 'v*'
|
||||
workflow_dispatch:
|
||||
|
||||
permissions:
|
||||
contents: write
|
||||
|
||||
jobs:
|
||||
build:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Set up JDK 17
|
||||
uses: actions/setup-java@v4
|
||||
with:
|
||||
distribution: temurin
|
||||
java-version: '17'
|
||||
|
||||
- name: Set up Android SDK
|
||||
uses: android-actions/setup-android@v3
|
||||
|
||||
- name: Build debug APK
|
||||
run: |
|
||||
chmod +x ./gradlew
|
||||
./gradlew :app:assembleDebug --stacktrace --no-daemon
|
||||
|
||||
- name: Stage APK
|
||||
run: |
|
||||
mkdir -p out
|
||||
cp app/build/outputs/apk/debug/app-debug.apk "out/OVERWATCH-${GITHUB_REF_NAME}.apk"
|
||||
|
||||
# Uploaded on every run (incl. workflow_dispatch) so a build can be
|
||||
# validated without cutting a release.
|
||||
- name: Upload APK artifact
|
||||
uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: overwatch-apk
|
||||
path: out/*.apk
|
||||
|
||||
# Only tag pushes (v*) create a GitHub Release with the APK attached.
|
||||
- name: Publish Release
|
||||
if: startsWith(github.ref, 'refs/tags/')
|
||||
uses: softprops/action-gh-release@v2
|
||||
with:
|
||||
files: out/*.apk
|
||||
generate_release_notes: true
|
||||
@@ -4,33 +4,27 @@
|
||||
A native Android (Kotlin) **passive surveillance-detection** app. Open it, hit
|
||||
**START**, and a circle turns **green / yellow / orange / red** depending on
|
||||
how confident the engine is that there's a Flock Safety ALPR, an Axon body
|
||||
camera, or active police presence near you. With the screen locked, the
|
||||
foreground notification updates with the current tier and the phone vibrates
|
||||
on upward escalations — you don't have to be looking at the screen.
|
||||
camera, or police presence near you.
|
||||
|
||||
> **Passive defense only.** OVERWATCH only listens — it does not transmit,
|
||||
> probe, jam, or interfere with any device or network. The Axon
|
||||
> advertise/fuzz code from one of the reference projects is intentionally
|
||||
> excluded.
|
||||
|
||||
Latest release: [v0.5.1](https://github.com/KaraZajac/OVERWATCH/releases) (debug-signed APK, sideload).
|
||||
|
||||
---
|
||||
|
||||
## What it detects
|
||||
|
||||
| Source | What it looks at | Where it comes from |
|
||||
|---|---|---|
|
||||
| **BLE** | Bluetooth-LE advertisements: vendor MAC OUIs (Axon, Flock Penguin / Raven, XUNTONG mfg id `0x09C8`, "TN" serial pattern), Raven service UUIDs, device-name patterns | Local radio scan (BLE callback API). Iterates every manufacturer-specific data entry to find XUNTONG, not just the first. |
|
||||
| **BLE** | Bluetooth-LE advertisements: vendor MAC OUIs (Axon, Flock Penguin / Raven, XUNTONG mfg id `0x09C8`, "TN" serial pattern), Raven service UUIDs, device-name patterns | Local radio scan (BLE callback API) |
|
||||
| **WiFi** | BSSID OUI prefixes for Flock infrastructure (31-prefix superset), `Flock-XXXX` and other generic SSID patterns | `WifiManager.getScanResults()` polled every 35 s (just under the Android 11+ 4-scans/2-min throttle) |
|
||||
| **DEFLOCK** | Crowdsourced ALPR locations within configurable proximity (default 200 m) | POST to Overpass API (`overpass.deflock.org` → fallback `overpass-api.de`) for `man_made=surveillance + surveillance:type=ALPR` in a 5 km bbox; 24 h on-disk cache by 0.05° grid cell. Refetches when the user moves > 1.5 km from the last fetch center. Backoffs after Overpass failures; treats `{"remark": "...timed out..."}` 200-responses as failure so timeouts don't poison the cache. |
|
||||
| **CITIZEN** | Real-time public-safety incidents (police-relevant only — fire/medical-only events filtered out) within configurable proximity, < 30 min old | `citizen.com/api/incident/trending` (bbox) polled every 60 s, then per-incident detail via `/api/incident/{id}` with an in-memory cache so each incident is fetched once per session. First poll fires immediately on the first location fix. |
|
||||
| **WAZE** | User-reported `POLICE` alerts still active in the feed within configurable proximity (default 500 m), up to ~45 min old | `api.blackflagintel.com/waze/alerts-and-jams` — the OVERWATCH proxy (Caddy) that injects the OpenWeb Ninja key server-side and forwards to their hosted Waze scrape, sidestepping the reCAPTCHA gating that 403s direct `live-map/api/georss` calls. The app authenticates with an `X-App-Token` entered in Settings (encrypted on-device); the paid key never ships in the APK. Polled every ~4 min. Upstream ignores type filtering and caps at 200 alerts, so the client pulls the full page and filters to `POLICE` itself. Alerts carry confidence (0–5) + reliability (0–10); high values nudge the score up. No token → source shows "not configured" in the drill-down. |
|
||||
| **COMMERCIAL** | Nearby consumer smart-home / voice-assistant gear (Nest, Ring, Echo, hidden cams) as a secondary situational signal | Rides the BLE + WiFi scans — OUI / device-name / service-UUID / SSID matches from `MicTargets`. Score-capped at ORANGE so a cluster of doorbells never reads as ALPR-grade certainty. |
|
||||
| **DEFLOCK** | Crowdsourced ALPR locations within configurable proximity (default 200 m) | POST to Overpass API (`overpass.deflock.org` → fallback `overpass-api.de`) for `man_made=surveillance + surveillance:type=ALPR` in a 5 km bbox; 24 h on-disk cache by 0.05° grid cell. Refetches when the user moves > 1.5 km from the last fetch center. |
|
||||
| **CITIZEN** | Real-time public-safety incidents (police-relevant only — fire/medical-only events filtered out) within configurable proximity, < 30 min old | `citizen.com/api/incident/trending` (bbox) polled every 60 s, then per-incident detail via `/api/incident/{id}` with an in-memory cache so each incident is fetched once per session. |
|
||||
|
||||
> **Waze is back (v0.4.0+), via a key-protected proxy.** Waze reCAPTCHA-gated its `live-map/api/georss` endpoint in 2025/2026 — automated calls get HTTP 403 regardless of IP or headless-vs-headful browser (it scores browser *reputation*, verified by direct testing), which is why v0.1.5 removed the original integration and why no free scraper survives. OVERWATCH reads Waze POLICE alerts through [OpenWeb Ninja](https://www.openwebninja.com)'s hosted feed (pay-as-you-go ~$0.005/req, ≈ $1–3/mo at the 4-min poll). To keep the paid key off every device, the app doesn't hold it: a Caddy reverse proxy at `api.blackflagintel.com` injects the key server-side, and the app authenticates with a scoped, revocable `X-App-Token` entered in Settings (stored encrypted via the Android Keystore). The Waze for Cities partner feed was ruled out — it excludes POLICE and is agency-only. Waze complements Citizen: denser for roadway stops / speed traps.
|
||||
> **Why no Waze?** Waze added reCAPTCHA gating to its `live-map/api/georss` endpoint in 2025/2026. Mobile clients receive HTTP 403, and the only known workarounds (Selenium proxy on a home server, Waze for Cities partner program) aren't viable for a phone-deployed app. Citizen replaces it.
|
||||
|
||||
Every observation is scored 0–100 by `ConfidenceEngine`. The on-screen tier is
|
||||
Every observation is scored 0-100 by `ConfidenceEngine`. The on-screen tier is
|
||||
the maximum live score across all sources:
|
||||
|
||||
```
|
||||
@@ -42,83 +36,45 @@ RED 85 + certain
|
||||
|
||||
The user-facing circle uses the full 4-tier mapping. Cross-source corroboration
|
||||
naturally pushes the global max upward (a BLE OUI hit *and* a DeFlock map
|
||||
match in the same area produce a higher tier than either alone). When idle,
|
||||
the circle shows muted gray with `IDLE` text so it's distinguishable at a
|
||||
glance from "scanning, all clear."
|
||||
|
||||
While scanning, the circle becomes a live OpenStreetMap centered on you, wrapped
|
||||
in a **threat-color ring** (the current tier at a glance) and marked with a ⌖
|
||||
crosshair for your position. Map geodata is color-coded by source — **Flock /
|
||||
DeFlock cameras red, Waze police blue, Citizen incidents purple** — so each dot
|
||||
is self-explanatory. The same map renders in a smaller floating overlay bubble
|
||||
(Settings → Display over other apps) so it works over other apps.
|
||||
|
||||
---
|
||||
|
||||
## How alerts work
|
||||
|
||||
- **In-app**: the threat circle shows a live map with a threat-color ring and
|
||||
source-color dots while scanning; tap it to open the bottom-sheet drill-down
|
||||
with per-source rows. DeFlock, Citizen, and Waze events carry coordinates —
|
||||
each row has a tap-to-open Maps icon.
|
||||
- **Foreground notification**: rebuilt on every threat-tier change. Title
|
||||
becomes `OVERWATCH • RED` (or whatever tier); text shows the top
|
||||
detection's score + label. Notification priority bumps to HIGH on RED so
|
||||
the system can surface it as a heads-up.
|
||||
- **Vibration**: on upward tier transitions only. Short pulse for YELLOW,
|
||||
double for ORANGE, escalating triple for RED. Toggle in Settings → Alerts.
|
||||
- **Per-source health**: the drill-down sheet shows orange `Source unreachable`
|
||||
text on a row when its scanner couldn't reach its data source — silent
|
||||
empty results vs. real failures are distinguishable.
|
||||
match in the same area produce a higher tier than either alone).
|
||||
|
||||
---
|
||||
|
||||
## Architecture
|
||||
|
||||
```
|
||||
ui/MainScreen.kt map circle + threat ring + START/STOP + drill-down sheet
|
||||
ui/OverlayBubble.kt floating "chat-bubble" version of the map circle
|
||||
ui/MarkerIcons.kt map marker drawables — source dots + ⌖ user crosshair
|
||||
ui/SettingsScreen.kt source toggles, distance sliders, Waze token, vibrate, theme
|
||||
ui/theme/Theme.kt Material 3 dark/light + threat colors
|
||||
service/DetectionService.kt foreground service — owns scanners, notification, vibration
|
||||
service/OverlayManager.kt WindowManager host for the floating overlay bubble
|
||||
scan/BleScanner.kt BLE callback scanner
|
||||
scan/WifiScanner.kt WifiManager poller + SCAN_RESULTS receiver
|
||||
scan/DeflockClient.kt Overpass POST (deflock.org → overpass-api.de) + 24h cache
|
||||
scan/DeflockScanner.kt location-driven proximity check + failure backoff
|
||||
scan/CitizenClient.kt GET /api/incident/trending + /api/incident/{id}
|
||||
scan/CitizenScanner.kt 60 s poller, fire/medical filter, per-id cache
|
||||
scan/WazeClient.kt GET api.blackflagintel.com proxy (X-App-Token) → OpenWeb Ninja
|
||||
scan/WazeScanner.kt ~4 min poller, 200-alert page, client-side POLICE filter
|
||||
fusion/ConfidenceEngine.kt scoring (BLE / WiFi / DeFlock / Citizen / Waze / Commercial)
|
||||
fusion/RssiTracker.kt rise-peak-fall stationary-signal detector
|
||||
fusion/DetectionStore.kt in-memory dedup, 5-min retention, max-tier flow
|
||||
fusion/SourceHealth.kt per-source OK/FAILED registry for the drill-down
|
||||
fusion/ThreatLevel.kt 4-tier enum + DetectionSource enum
|
||||
ui/MainScreen.kt circle + START/STOP + tap-to-open bottom sheet
|
||||
ui/SettingsScreen.kt per-source toggles, distance sliders, theme
|
||||
service/DetectionService.kt foreground service — owns scanners + store
|
||||
scan/BleScanner.kt BLE callback scanner
|
||||
scan/WifiScanner.kt WifiManager poller + SCAN_RESULTS receiver
|
||||
scan/DeflockClient.kt CDN tile fetch + 24h cache
|
||||
scan/DeflockScanner.kt location-driven proximity check
|
||||
scan/WazeClient.kt live-map/api/georss bbox fetch
|
||||
scan/WazeScanner.kt 60s poller + age/distance gate
|
||||
fusion/ConfidenceEngine.kt scoring (one place)
|
||||
fusion/RssiTracker.kt rise-peak-fall stationary-signal detector
|
||||
fusion/DetectionStore.kt in-memory dedup, 5-min retention
|
||||
data/location/LocationProvider.kt FusedLocationProviderClient wrapper
|
||||
data/settings/Settings.kt SharedPreferences-backed StateFlow settings
|
||||
data/settings/SecureStore.kt Keystore AES/GCM store for the Waze proxy token
|
||||
data/targets/ BleOuis, WifiOuis, RavenUuids, Patterns, Manufacturers, MicTargets
|
||||
data/settings/Settings.kt SharedPreferences-backed StateFlow settings
|
||||
data/targets/ BleOuis, WifiOuis, RavenUuids, Patterns, Manufacturers
|
||||
```
|
||||
|
||||
No detection-history database. All state is in-memory and clears on stop, by
|
||||
design. Service uses `START_NOT_STICKY` — system kill doesn't auto-restart
|
||||
into a stuck state.
|
||||
design.
|
||||
|
||||
---
|
||||
|
||||
## Build & install
|
||||
|
||||
Requires:
|
||||
- **JDK 17** (17 or 21; Android Gradle Plugin 8.7.x rejects JDK 26)
|
||||
- **Android Studio** with SDK Platform 35 + Build-Tools 35.x + Platform-Tools
|
||||
- **JDK 21** (Android Gradle Plugin 8.7.x rejects JDK 26)
|
||||
- **Android Studio** with SDK Platform 34 + Build-Tools 34.x + Platform-Tools
|
||||
|
||||
```sh
|
||||
# 1) Copy the example local.properties and point sdk.dir at your install
|
||||
cp local.properties.example local.properties
|
||||
# edit local.properties → sdk.dir=/Users/<you>/Library/Android/sdk
|
||||
# (Waze needs no build config — paste the proxy token into Settings in-app)
|
||||
|
||||
# 2) Make sure JAVA_HOME is JDK 21
|
||||
export JAVA_HOME=/usr/local/opt/openjdk@21/libexec/openjdk.jdk/Contents/Home
|
||||
@@ -127,13 +83,9 @@ export JAVA_HOME=/usr/local/opt/openjdk@21/libexec/openjdk.jdk/Contents/Home
|
||||
./gradlew :app:installDebug
|
||||
```
|
||||
|
||||
Or download the latest debug-signed APK from
|
||||
Or download the latest signed APK from
|
||||
[Releases](https://github.com/KaraZajac/OVERWATCH/releases).
|
||||
|
||||
Releases are cut by CI: pushing a `v*` tag runs `.github/workflows/release.yml`,
|
||||
which builds `:app:assembleDebug` and attaches the APK to a GitHub Release. No
|
||||
build-time secrets — the app ships with no key or token.
|
||||
|
||||
---
|
||||
|
||||
## Permissions
|
||||
@@ -142,19 +94,14 @@ build-time secrets — the app ships with no key or token.
|
||||
|---|---|
|
||||
| `BLUETOOTH_SCAN`, `BLUETOOTH_CONNECT` (API 31+) | BLE scanning |
|
||||
| `BLUETOOTH`, `BLUETOOTH_ADMIN` (≤ API 30) | BLE scanning, legacy |
|
||||
| `ACCESS_FINE_LOCATION` | Required for BLE pre-S, WiFi pre-T, and DeFlock/Citizen proximity |
|
||||
| `ACCESS_FINE_LOCATION` | Required for BLE pre-S, WiFi pre-T, and DeFlock proximity |
|
||||
| `NEARBY_WIFI_DEVICES` (API 33+) | WiFi scan results without using location |
|
||||
| `ACCESS_WIFI_STATE`, `CHANGE_WIFI_STATE` | Trigger and read scan results |
|
||||
| `INTERNET`, `ACCESS_NETWORK_STATE` | DeFlock Overpass, Citizen API, Waze proxy |
|
||||
| `INTERNET`, `ACCESS_NETWORK_STATE` | DeFlock CDN + Waze API |
|
||||
| `FOREGROUND_SERVICE`, `FOREGROUND_SERVICE_CONNECTED_DEVICE`, `FOREGROUND_SERVICE_LOCATION` | Keep scanning with the screen off |
|
||||
| `POST_NOTIFICATIONS` (API 33+) | Foreground-service notification |
|
||||
| `VIBRATE` | Haptic alert on threat-tier escalation |
|
||||
| `SYSTEM_ALERT_WINDOW` | Optional floating threat-circle overlay (special-access; granted via system settings) |
|
||||
|
||||
Requested at runtime when you press START for the first time. If you
|
||||
permanently deny a required permission ("don't ask again"), the START button
|
||||
swaps to **Open app settings** which fires the per-app system-settings page
|
||||
so you can grant manually.
|
||||
Requested at runtime when you press START for the first time.
|
||||
|
||||
---
|
||||
|
||||
@@ -162,20 +109,11 @@ so you can grant manually.
|
||||
|
||||
Tap the gear icon in the top-right.
|
||||
|
||||
- **Detection sources**: toggle BLE / WiFi / DeFlock / Citizen / Waze / Commercial independently.
|
||||
Changes take effect on the next Start. While scanning, a **Restart scan to
|
||||
apply** button appears that does `stop()` + `start()` in one tap.
|
||||
- **Proximity thresholds** (sliders commit on release, not per-pixel):
|
||||
- **Detection sources**: toggle BLE / WiFi / DeFlock / Waze independently. Takes
|
||||
effect on next Start.
|
||||
- **Proximity thresholds**:
|
||||
- DeFlock: 50 m – 1600 m (default 200 m)
|
||||
- Citizen: 100 m – 5000 m (default 500 m)
|
||||
- Waze: 100 m – 5000 m (default 500 m)
|
||||
- **Waze police feed**: paste the `api.blackflagintel.com` proxy token. It's
|
||||
stored encrypted on-device (Android Keystore), never baked into the APK; the
|
||||
paid OpenWeb Ninja key stays server-side on the proxy. Empty = Waze source off.
|
||||
- **Alerts**:
|
||||
- Vibrate on threat escalation (default on)
|
||||
- **Display over other apps**: floating threat-circle overlay (needs the
|
||||
special-access permission; the app bounces you to the system page to grant it).
|
||||
- **Appearance**: System / Dark / Light (default Dark)
|
||||
|
||||
---
|
||||
@@ -187,27 +125,15 @@ These live under `REFERENCES/` (gitignored):
|
||||
- **AxonCadabra** — BLE scanner skeleton (scan side only; advertise/fuzz code excluded)
|
||||
- **flock-detection** — confidence-scoring algorithm (highest reusability), RSSI rise-peak-fall, OUIs + UUIDs + patterns
|
||||
- **flock-you** — 31-OUI WiFi superset (promiscuous-mode tricks not portable to Android)
|
||||
- **deflock** + **deflock-app** — Overpass query format + proximity-alert pattern (the Flutter app uses Overpass directly, not the CDN tiles, which the OVERWATCH client mirrors)
|
||||
- **wazepolice** — original live-map/api/georss recipe; that endpoint is now reCAPTCHA-gated, so v0.5.0 re-added Waze via the OpenWeb Ninja proxy (`api.blackflagintel.com`) instead of hitting Waze directly
|
||||
- **deflock** + **deflock-app** — CDN tile scheme, proximity-alert pattern
|
||||
- **wazepolice** — live-map/api/georss recipe, Chrome header spoofing
|
||||
|
||||
---
|
||||
|
||||
## Status
|
||||
|
||||
Phases 1–5 (skeleton, BLE, WiFi, DeFlock, Citizen, polish) complete and
|
||||
field-tested. Current release **v0.5.1**. Notable changes:
|
||||
|
||||
- v0.1.2 — Android 14+ foreground service type fix; NaN-coordinate filter on map data.
|
||||
- v0.1.3 — DeFlock CDN replaced by direct Overpass calls (Cloudflare-blocked).
|
||||
- v0.1.4 — Citizen.com added as 5th source, per-source health registry.
|
||||
- v0.1.5 — Waze removed (reCAPTCHA-gated; no clean mobile workaround at the time).
|
||||
- v0.1.6 — Dynamic notification with tier + label, haptic alerts, Open-in-Maps for geo events.
|
||||
- v0.1.7 — System back from Settings returns to MAIN instead of exiting.
|
||||
- v0.2.0 — Live map circle + COMMERCIAL source (Nest / Ring / Echo / hidden cams).
|
||||
- v0.2.1–v0.2.2 — Live proximity refresh, map dot markers, map + Settings UI polish.
|
||||
- v0.3.0–v0.3.2 — Floating threat-circle overlay (chat-bubble style) + drag/crash fixes.
|
||||
- v0.5.0 — Waze re-added via a key-protected Caddy proxy (`api.blackflagintel.com`): the OpenWeb Ninja key stays server-side, the app uses an encrypted per-device token. GitHub Actions release pipeline added.
|
||||
- v0.5.1 — UI: larger map circle with a threat-color ring, ⌖ user crosshair, source-color dots (Flock red / Waze blue / Citizen purple), START moved to the bottom.
|
||||
Phases 1–5 (skeleton, BLE, WiFi, DeFlock, Waze, polish) complete as of v0.1.0.
|
||||
Field-test-ready, not yet field-validated.
|
||||
|
||||
## License
|
||||
|
||||
|
||||
@@ -12,8 +12,8 @@ android {
|
||||
applicationId = "org.soulstone.overwatch"
|
||||
minSdk = 26
|
||||
targetSdk = 35
|
||||
versionCode = 17
|
||||
versionName = "0.5.1"
|
||||
versionCode = 7
|
||||
versionName = "0.1.6"
|
||||
}
|
||||
|
||||
buildTypes {
|
||||
@@ -61,7 +61,6 @@ dependencies {
|
||||
implementation(libs.androidx.compose.material.icons.extended)
|
||||
|
||||
implementation(libs.play.services.location)
|
||||
implementation(libs.osmdroid.android)
|
||||
|
||||
debugImplementation(libs.androidx.compose.ui.tooling)
|
||||
}
|
||||
|
||||
@@ -38,21 +38,8 @@
|
||||
<!-- Vibration on threat-tier escalation -->
|
||||
<uses-permission android:name="android.permission.VIBRATE" />
|
||||
|
||||
<!-- Floating threat-circle overlay (chat-bubble style). Special-access
|
||||
permission — user grants via system Settings page, not the runtime
|
||||
prompt. Only consumed when the user opts in to the bubble in app
|
||||
Settings; otherwise dormant. -->
|
||||
<uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />
|
||||
|
||||
<uses-feature android:name="android.hardware.bluetooth_le" android:required="true" />
|
||||
|
||||
<!-- Allow Intent.setPackage("com.google.android.apps.maps") on Android 11+
|
||||
(package visibility) so we can force "Open in Maps" pins to land in
|
||||
Google Maps regardless of the user's default geo: handler. -->
|
||||
<queries>
|
||||
<package android:name="com.google.android.apps.maps" />
|
||||
</queries>
|
||||
|
||||
<application
|
||||
android:allowBackup="false"
|
||||
android:dataExtractionRules="@xml/data_extraction_rules"
|
||||
|
||||
@@ -9,7 +9,6 @@ import android.os.Build
|
||||
import android.os.Bundle
|
||||
import android.provider.Settings as AndroidSettings
|
||||
import androidx.activity.ComponentActivity
|
||||
import androidx.activity.compose.BackHandler
|
||||
import androidx.activity.compose.setContent
|
||||
import androidx.activity.result.contract.ActivityResultContracts
|
||||
import androidx.compose.runtime.collectAsState
|
||||
@@ -19,7 +18,6 @@ import androidx.compose.runtime.saveable.rememberSaveable
|
||||
import androidx.compose.runtime.setValue
|
||||
import androidx.core.app.ActivityCompat
|
||||
import androidx.core.content.ContextCompat
|
||||
import org.osmdroid.config.Configuration
|
||||
import org.soulstone.overwatch.data.settings.Settings
|
||||
import org.soulstone.overwatch.service.DetectionService
|
||||
import org.soulstone.overwatch.ui.MainScreen
|
||||
@@ -67,14 +65,6 @@ class MainActivity : ComponentActivity() {
|
||||
|
||||
override fun onCreate(savedInstanceState: Bundle?) {
|
||||
super.onCreate(savedInstanceState)
|
||||
// osmdroid requires a User-Agent and a writable cache before any
|
||||
// MapView is constructed, otherwise OSM may rate-limit/IP-ban us.
|
||||
// Set it here once per process — Configuration is a singleton.
|
||||
Configuration.getInstance().apply {
|
||||
userAgentValue = packageName
|
||||
osmdroidBasePath = cacheDir
|
||||
osmdroidTileCache = java.io.File(cacheDir, "osmdroid-tiles").apply { mkdirs() }
|
||||
}
|
||||
permissionsGranted.value = checkAllPermissions()
|
||||
permanentlyDenied.value = false // reset on activity create
|
||||
val settings = Settings.get(this)
|
||||
@@ -90,17 +80,6 @@ class MainActivity : ComponentActivity() {
|
||||
val events by DetectionService.store.events.collectAsState()
|
||||
val threat by DetectionService.store.threatLevel.collectAsState()
|
||||
val maxScore by DetectionService.store.maxScore.collectAsState()
|
||||
val mapPoints by DetectionService.mapPoints.collectAsState()
|
||||
val userLocation by DetectionService.location.collectAsState()
|
||||
// Visible map radius = max of the two proximity sliders
|
||||
// so the user sees the full area where a detection
|
||||
// can fire. Using the raw setting values regardless of
|
||||
// enabled-state keeps the visualization stable when a
|
||||
// source is briefly toggled.
|
||||
val deflockProx by settings.deflockProximityM.collectAsState()
|
||||
val citizenProx by settings.citizenProximityM.collectAsState()
|
||||
val wazeProx by settings.wazeProximityM.collectAsState()
|
||||
val mapRadiusM = maxOf(deflockProx, citizenProx, wazeProx).toFloat()
|
||||
val granted by permissionsGranted
|
||||
val denied by permanentlyDenied
|
||||
|
||||
@@ -115,9 +94,6 @@ class MainActivity : ComponentActivity() {
|
||||
threat = threat,
|
||||
score = maxScore,
|
||||
events = events,
|
||||
mapPoints = mapPoints,
|
||||
userLocation = userLocation,
|
||||
mapRadiusMeters = mapRadiusM,
|
||||
canStart = true,
|
||||
permissionMessage = message,
|
||||
showOpenAppSettings = denied && !granted,
|
||||
@@ -139,10 +115,6 @@ class MainActivity : ComponentActivity() {
|
||||
)
|
||||
}
|
||||
Screen.SETTINGS -> {
|
||||
// Route system back into MAIN instead of letting the
|
||||
// activity finish — the screen enum is internal to
|
||||
// Compose and the OS doesn't know about it.
|
||||
BackHandler { screen = Screen.MAIN }
|
||||
val running by DetectionService.running.collectAsState()
|
||||
SettingsScreen(
|
||||
settings = settings,
|
||||
|
||||
@@ -1,89 +0,0 @@
|
||||
package org.soulstone.overwatch.data.settings
|
||||
|
||||
import android.content.Context
|
||||
import android.security.keystore.KeyGenParameterSpec
|
||||
import android.security.keystore.KeyProperties
|
||||
import android.util.Base64
|
||||
import android.util.Log
|
||||
import androidx.core.content.edit
|
||||
import java.security.KeyStore
|
||||
import javax.crypto.Cipher
|
||||
import javax.crypto.KeyGenerator
|
||||
import javax.crypto.SecretKey
|
||||
import javax.crypto.spec.GCMParameterSpec
|
||||
|
||||
/**
|
||||
* Tiny at-rest secret store for on-device credentials (the Waze proxy token).
|
||||
*
|
||||
* Values are AES/GCM-encrypted with a key held in the Android Keystore (hardware
|
||||
* -backed where available and never exportable), and the ciphertext is kept in
|
||||
* app-private SharedPreferences. This protects the token beyond plain prefs —
|
||||
* against device backups, rooted-device extraction, and forensic access — so a
|
||||
* shared/published APK carries no credential and a compromised backup yields
|
||||
* nothing usable.
|
||||
*
|
||||
* No third-party dependency (Jetpack Security's EncryptedSharedPreferences is in
|
||||
* maintenance limbo); this is ~40 lines of standard Keystore AES/GCM instead.
|
||||
*/
|
||||
object SecureStore {
|
||||
|
||||
private const val TAG = "SecureStore"
|
||||
private const val PREFS = "overwatch_secure"
|
||||
private const val KEY_ALIAS = "overwatch_secret_key"
|
||||
private const val ANDROID_KEYSTORE = "AndroidKeyStore"
|
||||
private const val TRANSFORMATION = "AES/GCM/NoPadding"
|
||||
private const val IV_LEN = 12
|
||||
private const val GCM_TAG_BITS = 128
|
||||
|
||||
private fun getOrCreateKey(): SecretKey {
|
||||
val ks = KeyStore.getInstance(ANDROID_KEYSTORE).apply { load(null) }
|
||||
(ks.getEntry(KEY_ALIAS, null) as? KeyStore.SecretKeyEntry)?.let { return it.secretKey }
|
||||
val generator = KeyGenerator.getInstance(KeyProperties.KEY_ALGORITHM_AES, ANDROID_KEYSTORE)
|
||||
generator.init(
|
||||
KeyGenParameterSpec.Builder(
|
||||
KEY_ALIAS,
|
||||
KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT
|
||||
)
|
||||
.setBlockModes(KeyProperties.BLOCK_MODE_GCM)
|
||||
.setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
|
||||
.build()
|
||||
)
|
||||
return generator.generateKey()
|
||||
}
|
||||
|
||||
/** Encrypt + persist [value] under [name]. Empty string clears the entry. */
|
||||
fun put(context: Context, name: String, value: String) {
|
||||
val prefs = context.applicationContext.getSharedPreferences(PREFS, Context.MODE_PRIVATE)
|
||||
if (value.isEmpty()) {
|
||||
prefs.edit { remove(name) }
|
||||
return
|
||||
}
|
||||
try {
|
||||
val cipher = Cipher.getInstance(TRANSFORMATION)
|
||||
cipher.init(Cipher.ENCRYPT_MODE, getOrCreateKey())
|
||||
val ct = cipher.doFinal(value.toByteArray(Charsets.UTF_8))
|
||||
// Prepend the (12-byte) IV so decryption is self-contained.
|
||||
val blob = Base64.encodeToString(cipher.iv + ct, Base64.NO_WRAP)
|
||||
prefs.edit { putString(name, blob) }
|
||||
} catch (e: Exception) {
|
||||
Log.w(TAG, "Failed to store secret '$name': ${e.message}")
|
||||
}
|
||||
}
|
||||
|
||||
/** Decrypt the value stored under [name], or null if absent/undecryptable. */
|
||||
fun get(context: Context, name: String): String? {
|
||||
val prefs = context.applicationContext.getSharedPreferences(PREFS, Context.MODE_PRIVATE)
|
||||
val blob = prefs.getString(name, null) ?: return null
|
||||
return try {
|
||||
val bytes = Base64.decode(blob, Base64.NO_WRAP)
|
||||
val iv = bytes.copyOfRange(0, IV_LEN)
|
||||
val ct = bytes.copyOfRange(IV_LEN, bytes.size)
|
||||
val cipher = Cipher.getInstance(TRANSFORMATION)
|
||||
cipher.init(Cipher.DECRYPT_MODE, getOrCreateKey(), GCMParameterSpec(GCM_TAG_BITS, iv))
|
||||
String(cipher.doFinal(ct), Charsets.UTF_8)
|
||||
} catch (e: Exception) {
|
||||
Log.w(TAG, "Failed to read secret '$name': ${e.message}")
|
||||
null
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -16,10 +16,7 @@ import kotlinx.coroutines.flow.asStateFlow
|
||||
* Per-source toggles only take effect at the next Start cycle — flipping a
|
||||
* source while scanning will NOT live-restart that scanner.
|
||||
*/
|
||||
class Settings private constructor(
|
||||
private val prefs: SharedPreferences,
|
||||
private val appContext: Context
|
||||
) {
|
||||
class Settings private constructor(private val prefs: SharedPreferences) {
|
||||
|
||||
enum class ThemeMode { SYSTEM, DARK, LIGHT }
|
||||
|
||||
@@ -35,12 +32,6 @@ class Settings private constructor(
|
||||
private val _citizenEnabled = MutableStateFlow(prefs.getBoolean(KEY_CITIZEN, true))
|
||||
val citizenEnabled: StateFlow<Boolean> = _citizenEnabled.asStateFlow()
|
||||
|
||||
private val _wazeEnabled = MutableStateFlow(prefs.getBoolean(KEY_WAZE, true))
|
||||
val wazeEnabled: StateFlow<Boolean> = _wazeEnabled.asStateFlow()
|
||||
|
||||
private val _micEnabled = MutableStateFlow(prefs.getBoolean(KEY_MIC, true))
|
||||
val micEnabled: StateFlow<Boolean> = _micEnabled.asStateFlow()
|
||||
|
||||
private val _deflockProximityM = MutableStateFlow(
|
||||
prefs.getInt(KEY_DEFLOCK_PROX, DEFAULT_DEFLOCK_PROX)
|
||||
)
|
||||
@@ -51,17 +42,6 @@ class Settings private constructor(
|
||||
)
|
||||
val citizenProximityM: StateFlow<Int> = _citizenProximityM.asStateFlow()
|
||||
|
||||
private val _wazeProximityM = MutableStateFlow(
|
||||
prefs.getInt(KEY_WAZE_PROX, DEFAULT_WAZE_PROX)
|
||||
)
|
||||
val wazeProximityM: StateFlow<Int> = _wazeProximityM.asStateFlow()
|
||||
|
||||
// Shared secret the app presents to the api.blackflagintel.com proxy, which
|
||||
// holds the real OpenWeb Ninja key server-side. Stored encrypted (Keystore),
|
||||
// never baked into the APK, so a published build carries no usable credential.
|
||||
private val _wazeProxyToken = MutableStateFlow(SecureStore.get(appContext, KEY_WAZE_TOKEN) ?: "")
|
||||
val wazeProxyToken: StateFlow<String> = _wazeProxyToken.asStateFlow()
|
||||
|
||||
private val _themeMode = MutableStateFlow(
|
||||
ThemeMode.valueOf(prefs.getString(KEY_THEME, ThemeMode.DARK.name) ?: ThemeMode.DARK.name)
|
||||
)
|
||||
@@ -70,15 +50,10 @@ class Settings private constructor(
|
||||
private val _vibrateOnAlert = MutableStateFlow(prefs.getBoolean(KEY_VIBRATE, true))
|
||||
val vibrateOnAlert: StateFlow<Boolean> = _vibrateOnAlert.asStateFlow()
|
||||
|
||||
private val _overlayEnabled = MutableStateFlow(prefs.getBoolean(KEY_OVERLAY, false))
|
||||
val overlayEnabled: StateFlow<Boolean> = _overlayEnabled.asStateFlow()
|
||||
|
||||
fun setBleEnabled(v: Boolean) { prefs.edit { putBoolean(KEY_BLE, v) }; _bleEnabled.value = v }
|
||||
fun setWifiEnabled(v: Boolean) { prefs.edit { putBoolean(KEY_WIFI, v) }; _wifiEnabled.value = v }
|
||||
fun setDeflockEnabled(v: Boolean) { prefs.edit { putBoolean(KEY_DEFLOCK, v) }; _deflockEnabled.value = v }
|
||||
fun setCitizenEnabled(v: Boolean) { prefs.edit { putBoolean(KEY_CITIZEN, v) }; _citizenEnabled.value = v }
|
||||
fun setWazeEnabled(v: Boolean) { prefs.edit { putBoolean(KEY_WAZE, v) }; _wazeEnabled.value = v }
|
||||
fun setMicEnabled(v: Boolean) { prefs.edit { putBoolean(KEY_MIC, v) }; _micEnabled.value = v }
|
||||
|
||||
fun setDeflockProximityM(v: Int) {
|
||||
val clamped = v.coerceIn(50, 1600)
|
||||
@@ -92,18 +67,6 @@ class Settings private constructor(
|
||||
_citizenProximityM.value = clamped
|
||||
}
|
||||
|
||||
fun setWazeProximityM(v: Int) {
|
||||
val clamped = v.coerceIn(100, 5000)
|
||||
prefs.edit { putInt(KEY_WAZE_PROX, clamped) }
|
||||
_wazeProximityM.value = clamped
|
||||
}
|
||||
|
||||
fun setWazeProxyToken(v: String) {
|
||||
val t = v.trim()
|
||||
SecureStore.put(appContext, KEY_WAZE_TOKEN, t)
|
||||
_wazeProxyToken.value = t
|
||||
}
|
||||
|
||||
fun setThemeMode(mode: ThemeMode) {
|
||||
prefs.edit { putString(KEY_THEME, mode.name) }
|
||||
_themeMode.value = mode
|
||||
@@ -114,37 +77,25 @@ class Settings private constructor(
|
||||
_vibrateOnAlert.value = v
|
||||
}
|
||||
|
||||
fun setOverlayEnabled(v: Boolean) {
|
||||
prefs.edit { putBoolean(KEY_OVERLAY, v) }
|
||||
_overlayEnabled.value = v
|
||||
}
|
||||
|
||||
companion object {
|
||||
private const val PREFS = "overwatch_settings"
|
||||
private const val KEY_BLE = "src_ble"
|
||||
private const val KEY_WIFI = "src_wifi"
|
||||
private const val KEY_DEFLOCK = "src_deflock"
|
||||
private const val KEY_CITIZEN = "src_citizen"
|
||||
private const val KEY_WAZE = "src_waze"
|
||||
private const val KEY_MIC = "src_mic"
|
||||
private const val KEY_DEFLOCK_PROX = "deflock_proximity_m"
|
||||
private const val KEY_CITIZEN_PROX = "citizen_proximity_m"
|
||||
private const val KEY_WAZE_PROX = "waze_proximity_m"
|
||||
private const val KEY_WAZE_TOKEN = "waze_proxy_token"
|
||||
private const val KEY_THEME = "theme_mode"
|
||||
private const val KEY_VIBRATE = "vibrate_on_alert"
|
||||
private const val KEY_OVERLAY = "overlay_enabled"
|
||||
|
||||
const val DEFAULT_DEFLOCK_PROX = 200
|
||||
const val DEFAULT_CITIZEN_PROX = 500
|
||||
const val DEFAULT_WAZE_PROX = 500
|
||||
|
||||
@Volatile private var INSTANCE: Settings? = null
|
||||
|
||||
fun get(context: Context): Settings = INSTANCE ?: synchronized(this) {
|
||||
INSTANCE ?: Settings(
|
||||
context.applicationContext.getSharedPreferences(PREFS, Context.MODE_PRIVATE),
|
||||
context.applicationContext
|
||||
context.applicationContext.getSharedPreferences(PREFS, Context.MODE_PRIVATE)
|
||||
).also { INSTANCE = it }
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,153 +0,0 @@
|
||||
package org.soulstone.overwatch.data.targets
|
||||
|
||||
import java.util.UUID
|
||||
|
||||
/**
|
||||
* Curated targets for "device with a microphone in your space" detection.
|
||||
*
|
||||
* Scope is intentionally narrow — only well-known smart-home OEMs whose devices
|
||||
* stay in fixed locations and continuously listen. Apple manufacturer id 0x004C
|
||||
* is deliberately excluded because every iPhone, AirPod, and Apple Watch
|
||||
* advertises it; a coffee shop full of phones must not light up the alarm.
|
||||
*
|
||||
* Detection vectors collected from public OUI registries (Wireshark/IEEE)
|
||||
* and device-setup advertisement docs.
|
||||
*/
|
||||
object MicTargets {
|
||||
|
||||
enum class Family { ECHO, RING, GOOGLE, HIDDEN_CAM }
|
||||
|
||||
/** Bluetooth SIG company identifiers for "voice/smart-home" device families. */
|
||||
private val MFG_GOOGLE = 0x00E0
|
||||
private val MFG_AMAZON = 0x0171
|
||||
/** Yingxin / cheap-spy-cam mfg id seen in field reports. */
|
||||
private val MFG_YINGXIN = 0x05A7
|
||||
|
||||
/** Echo/Alexa Voice Service GATT (FE03 — assigned to Amazon Lab126). */
|
||||
private val UUID_AVS = UUID.fromString("0000fe03-0000-1000-8000-00805f9b34fb")
|
||||
|
||||
/** Lab126 (Amazon — Echo, Ring, Fire TV) WiFi/BLE OUIs. */
|
||||
private val OUIS_AMAZON: Set<String> = setOf(
|
||||
"0c:47:c9", "38:f7:3d", "44:65:0d", "50:dc:e7", "78:e1:03",
|
||||
"a8:51:5b", "b0:09:da", "f0:27:2d", "f0:81:73", "f0:d2:f1",
|
||||
"fc:65:de", "fc:a1:83", "ac:63:be", "00:bb:3a"
|
||||
)
|
||||
|
||||
/** Google (Nest, Home, Chromecast) WiFi/BLE OUIs. */
|
||||
private val OUIS_GOOGLE: Set<String> = setOf(
|
||||
"f8:8f:ca", "f4:f5:e8", "94:eb:cd", "64:16:66", "fc:9f:e9",
|
||||
"1c:f2:9a", "08:9e:08", "20:df:b9", "30:fd:38", "48:d6:d5",
|
||||
"54:60:09", "6c:ad:f8", "70:3a:cb", "94:c9:60", "f4:f1:9e"
|
||||
)
|
||||
|
||||
/** Generic Chinese hidden-cam / smart-mic vendor OUIs (high-noise; opt-in). */
|
||||
private val OUIS_HIDDEN_CAM: Set<String> = setOf(
|
||||
"fc:b4:67", // Yingxin / SmartLife mini cams
|
||||
"00:e0:4c", // Realtek (used in many cheap cams)
|
||||
"dc:4f:22", // Tuya-affiliated module vendors
|
||||
"a4:c1:38", // Telink (often inside cheap BLE mics)
|
||||
"8c:ce:4e" // Shenzhen iComm — frequent in spy-cam BOMs
|
||||
)
|
||||
|
||||
private val ALL_OUIS: Set<String> = OUIS_AMAZON + OUIS_GOOGLE + OUIS_HIDDEN_CAM
|
||||
|
||||
/** Case-sensitive substrings — distinct enough to avoid false positives. */
|
||||
private val BLE_NAME_HINTS: List<Pair<String, Family>> = listOf(
|
||||
"Echo" to Family.ECHO,
|
||||
"echo-" to Family.ECHO,
|
||||
"FireTV" to Family.ECHO,
|
||||
"Amazon" to Family.ECHO,
|
||||
"Ring-" to Family.RING,
|
||||
"Ring " to Family.RING,
|
||||
"Doorbell" to Family.RING,
|
||||
"Nest" to Family.GOOGLE,
|
||||
"GoogleHome" to Family.GOOGLE,
|
||||
"Chromecast" to Family.GOOGLE,
|
||||
"Google-Home" to Family.GOOGLE
|
||||
)
|
||||
|
||||
private val SSID_HINTS: List<Pair<String, Family>> = listOf(
|
||||
"Amazon-" to Family.ECHO,
|
||||
"Echo-" to Family.ECHO,
|
||||
"Ring-" to Family.RING,
|
||||
"Ring_" to Family.RING,
|
||||
"Nest_" to Family.GOOGLE,
|
||||
"GoogleHome" to Family.GOOGLE,
|
||||
"Chromecast" to Family.GOOGLE
|
||||
)
|
||||
|
||||
data class Match(val family: Family, val reason: String)
|
||||
|
||||
fun matchOui(mac: String?): Family? {
|
||||
if (mac.isNullOrBlank() || mac.length < 8) return null
|
||||
val prefix = mac.lowercase().substring(0, 8)
|
||||
return when (prefix) {
|
||||
in OUIS_AMAZON -> Family.ECHO // Amazon OUIs cover both Echo and Ring
|
||||
in OUIS_GOOGLE -> Family.GOOGLE
|
||||
in OUIS_HIDDEN_CAM -> Family.HIDDEN_CAM
|
||||
else -> null
|
||||
}
|
||||
}
|
||||
|
||||
fun isMicOui(mac: String?): Boolean = matchOui(mac) != null
|
||||
|
||||
fun matchBleName(name: String?): Match? {
|
||||
if (name.isNullOrBlank()) return null
|
||||
for ((needle, family) in BLE_NAME_HINTS) {
|
||||
if (name.contains(needle, ignoreCase = false)) {
|
||||
return Match(family, "name:$needle")
|
||||
}
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
fun matchSsid(ssid: String?): Match? {
|
||||
if (ssid.isNullOrBlank()) return null
|
||||
for ((needle, family) in SSID_HINTS) {
|
||||
if (ssid.contains(needle, ignoreCase = true)) {
|
||||
return Match(family, "ssid:$needle")
|
||||
}
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
fun matchManufacturer(companyId: Int?): Family? = when (companyId) {
|
||||
MFG_AMAZON -> Family.ECHO
|
||||
MFG_GOOGLE -> Family.GOOGLE
|
||||
MFG_YINGXIN -> Family.HIDDEN_CAM
|
||||
else -> null
|
||||
}
|
||||
|
||||
fun matchAvsService(advertisedUuids: List<UUID>?): Boolean {
|
||||
if (advertisedUuids.isNullOrEmpty()) return false
|
||||
return advertisedUuids.contains(UUID_AVS)
|
||||
}
|
||||
|
||||
/** Cheap pre-filter for the BLE scanner — true if any mic signal could match. */
|
||||
fun couldBeMicBle(
|
||||
mac: String?,
|
||||
name: String?,
|
||||
advertisedUuids: List<UUID>?,
|
||||
companyId: Int?
|
||||
): Boolean {
|
||||
if (isMicOui(mac)) return true
|
||||
if (matchBleName(name) != null) return true
|
||||
if (matchManufacturer(companyId) != null) return true
|
||||
if (matchAvsService(advertisedUuids)) return true
|
||||
return false
|
||||
}
|
||||
|
||||
/** Cheap pre-filter for the WiFi scanner. */
|
||||
fun couldBeMicWifi(bssid: String?, ssid: String?): Boolean {
|
||||
if (isMicOui(bssid)) return true
|
||||
if (matchSsid(ssid) != null) return true
|
||||
return false
|
||||
}
|
||||
|
||||
fun familyLabel(f: Family): String = when (f) {
|
||||
Family.ECHO -> "Amazon Echo / Ring"
|
||||
Family.RING -> "Ring"
|
||||
Family.GOOGLE -> "Google Nest / Home"
|
||||
Family.HIDDEN_CAM -> "Possible hidden mic / cam"
|
||||
}
|
||||
}
|
||||
@@ -28,32 +28,16 @@ object ConfidenceEngine {
|
||||
const val W_DEFLOCK_NEAR = 60 // <= 200m
|
||||
const val W_DEFLOCK_VERY_NEAR = 85 // <= 50m
|
||||
|
||||
// Citizen (real-time incident feed)
|
||||
// Citizen (replaces Waze; Waze's reCAPTCHA gating made it unreachable)
|
||||
const val W_CITIZEN_INCIDENT = 55
|
||||
const val B_CITIZEN_LEVEL_BUMP = 5 // level >= 2
|
||||
const val B_CITIZEN_POLICE_TITLE = 5 // title contains a police-action keyword
|
||||
|
||||
// Waze (live POLICE alerts via the OpenWeb Ninja hosted feed)
|
||||
const val W_WAZE_POLICE = 55
|
||||
|
||||
// Bonuses
|
||||
const val B_MULTI_METHOD = 20
|
||||
const val B_STRONG_RSSI = 10 // > -50 dBm
|
||||
const val B_STATIONARY = 15 // RSSI rise-peak-fall
|
||||
|
||||
// MIC channel — smart-home/voice-assistant detection. Capped so a Ring or
|
||||
// Echo cluster can't push the global tier above ORANGE; RED stays reserved
|
||||
// for ALPR/Axon-grade evidence.
|
||||
const val MIC_SCORE_CAP = 84
|
||||
const val W_MIC_OUI = 30
|
||||
const val W_MIC_NAME = 45
|
||||
const val W_MIC_MFG = 30
|
||||
const val W_MIC_AVS_UUID = 50
|
||||
const val W_MIC_SSID = 45
|
||||
const val B_MIC_MULTI = 10
|
||||
const val B_MIC_STATIONARY = 8
|
||||
const val B_MIC_STRONG_RSSI = 5
|
||||
|
||||
/** What we observed about one BLE device on a single scan callback. */
|
||||
data class BleObservation(
|
||||
val mac: String,
|
||||
@@ -93,16 +77,6 @@ object ConfidenceEngine {
|
||||
val precinct: String?
|
||||
)
|
||||
|
||||
/** A Waze POLICE alert observed within proximity + freshness thresholds. */
|
||||
data class WazeObservation(
|
||||
val uuid: String,
|
||||
val distanceMeters: Float,
|
||||
val ageMs: Long,
|
||||
val confidence: Int, // raw 0-5
|
||||
val reliability: Int, // raw 0-10
|
||||
val subtype: String?
|
||||
)
|
||||
|
||||
data class Scored(
|
||||
val score: Int,
|
||||
val methods: String,
|
||||
@@ -219,22 +193,6 @@ object ConfidenceEngine {
|
||||
return Scored(score, tags.toString().trim(), label, isAxon = false)
|
||||
}
|
||||
|
||||
fun scoreWaze(obs: WazeObservation): Scored {
|
||||
// Baseline 55 for any POLICE alert within the proximity + age gate the
|
||||
// caller already applied. Small crowd-trust nudges for high reliability
|
||||
// and high confidence, capped well under the multi-method bonus so a
|
||||
// corroborating BLE/WiFi/DeFlock hit still dominates the global tier.
|
||||
var score = W_WAZE_POLICE
|
||||
if (obs.reliability >= 7) score += 5
|
||||
if (obs.confidence >= 4) score += 5
|
||||
score = score.coerceAtMost(100)
|
||||
val methods = "waze_police rel=${obs.reliability} conf=${obs.confidence}"
|
||||
val ageMin = (obs.ageMs / 60_000L).toInt()
|
||||
val sub = obs.subtype?.let { " ($it)" } ?: ""
|
||||
val label = "Police report$sub @ ${obs.distanceMeters.toInt()}m, ${ageMin}min ago"
|
||||
return Scored(score, methods, label, isAxon = false)
|
||||
}
|
||||
|
||||
fun scoreDeflock(obs: DeflockObservation): Scored {
|
||||
val score = if (obs.distanceMeters <= 50f) W_DEFLOCK_VERY_NEAR else W_DEFLOCK_NEAR
|
||||
val rangeTag = if (obs.distanceMeters <= 50f) "deflock<=50m" else "deflock<=200m"
|
||||
@@ -244,107 +202,6 @@ object ConfidenceEngine {
|
||||
return Scored(score, rangeTag, label, isAxon = false)
|
||||
}
|
||||
|
||||
/** A BLE mic-bearing-device observation, score-capped at ORANGE. */
|
||||
data class MicBleObservation(
|
||||
val mac: String,
|
||||
val rssi: Int,
|
||||
val deviceName: String?,
|
||||
val advertisedUuids: List<java.util.UUID>?,
|
||||
val manufacturerCompanyId: Int?,
|
||||
val isStationary: Boolean
|
||||
)
|
||||
|
||||
/** A WiFi mic-bearing-device observation, score-capped at ORANGE. */
|
||||
data class MicWifiObservation(
|
||||
val bssid: String,
|
||||
val ssid: String?,
|
||||
val rssi: Int,
|
||||
val isStationary: Boolean
|
||||
)
|
||||
|
||||
fun scoreMicBle(obs: MicBleObservation): Scored {
|
||||
var score = 0
|
||||
var methodCount = 0
|
||||
val methods = StringBuilder()
|
||||
val ouiFamily = org.soulstone.overwatch.data.targets.MicTargets.matchOui(obs.mac)
|
||||
if (ouiFamily != null) {
|
||||
score += W_MIC_OUI
|
||||
methods.append("mic_oui ")
|
||||
methodCount++
|
||||
}
|
||||
val nameMatch = org.soulstone.overwatch.data.targets.MicTargets.matchBleName(obs.deviceName)
|
||||
if (nameMatch != null) {
|
||||
score += W_MIC_NAME
|
||||
methods.append("mic_name ")
|
||||
methodCount++
|
||||
}
|
||||
val mfgFamily = org.soulstone.overwatch.data.targets.MicTargets.matchManufacturer(obs.manufacturerCompanyId)
|
||||
if (mfgFamily != null) {
|
||||
score += W_MIC_MFG
|
||||
methods.append("mic_mfg ")
|
||||
methodCount++
|
||||
}
|
||||
if (org.soulstone.overwatch.data.targets.MicTargets.matchAvsService(obs.advertisedUuids)) {
|
||||
score += W_MIC_AVS_UUID
|
||||
methods.append("mic_avs ")
|
||||
methodCount++
|
||||
}
|
||||
if (methodCount >= 2) {
|
||||
score += B_MIC_MULTI
|
||||
methods.append("multi ")
|
||||
}
|
||||
if (obs.rssi > -50) {
|
||||
score += B_MIC_STRONG_RSSI
|
||||
methods.append("strong_rssi ")
|
||||
}
|
||||
if (obs.isStationary) {
|
||||
score += B_MIC_STATIONARY
|
||||
methods.append("stationary ")
|
||||
}
|
||||
score = score.coerceAtMost(MIC_SCORE_CAP)
|
||||
val family = nameMatch?.family ?: ouiFamily ?: mfgFamily
|
||||
?: org.soulstone.overwatch.data.targets.MicTargets.Family.HIDDEN_CAM
|
||||
val familyLabel = org.soulstone.overwatch.data.targets.MicTargets.familyLabel(family)
|
||||
val nameSuffix = if (!obs.deviceName.isNullOrBlank()) " — ${obs.deviceName}" else ""
|
||||
return Scored(score, methods.toString().trim(), "$familyLabel$nameSuffix (${obs.mac})", isAxon = false)
|
||||
}
|
||||
|
||||
fun scoreMicWifi(obs: MicWifiObservation): Scored {
|
||||
var score = 0
|
||||
var methodCount = 0
|
||||
val methods = StringBuilder()
|
||||
val ouiFamily = org.soulstone.overwatch.data.targets.MicTargets.matchOui(obs.bssid)
|
||||
if (ouiFamily != null) {
|
||||
score += W_MIC_OUI
|
||||
methods.append("mic_oui ")
|
||||
methodCount++
|
||||
}
|
||||
val ssidMatch = org.soulstone.overwatch.data.targets.MicTargets.matchSsid(obs.ssid)
|
||||
if (ssidMatch != null) {
|
||||
score += W_MIC_SSID
|
||||
methods.append("mic_ssid ")
|
||||
methodCount++
|
||||
}
|
||||
if (methodCount >= 2) {
|
||||
score += B_MIC_MULTI
|
||||
methods.append("multi ")
|
||||
}
|
||||
if (obs.rssi > -50) {
|
||||
score += B_MIC_STRONG_RSSI
|
||||
methods.append("strong_rssi ")
|
||||
}
|
||||
if (obs.isStationary) {
|
||||
score += B_MIC_STATIONARY
|
||||
methods.append("stationary ")
|
||||
}
|
||||
score = score.coerceAtMost(MIC_SCORE_CAP)
|
||||
val family = ssidMatch?.family ?: ouiFamily
|
||||
?: org.soulstone.overwatch.data.targets.MicTargets.Family.HIDDEN_CAM
|
||||
val familyLabel = org.soulstone.overwatch.data.targets.MicTargets.familyLabel(family)
|
||||
val ssidSuffix = if (!obs.ssid.isNullOrBlank()) " — ${obs.ssid}" else ""
|
||||
return Scored(score, methods.toString().trim(), "$familyLabel$ssidSuffix (${obs.bssid})", isAxon = false)
|
||||
}
|
||||
|
||||
fun scoreWifi(obs: WifiObservation): Scored {
|
||||
var score = 0
|
||||
val methods = StringBuilder()
|
||||
|
||||
@@ -44,17 +44,6 @@ class DetectionStore(
|
||||
_maxScore.value = 0
|
||||
}
|
||||
|
||||
/** Drop every event from a single source — used when a proximity threshold
|
||||
* changes and the owning scanner needs to re-emit a fresh slate (events
|
||||
* outside the new radius would otherwise linger until their 5-min TTL). */
|
||||
@Synchronized
|
||||
fun clearSource(source: DetectionSource) {
|
||||
val remaining = _events.value.filter { it.source != source }
|
||||
if (remaining.size == _events.value.size) return
|
||||
_events.value = remaining
|
||||
recompute(remaining)
|
||||
}
|
||||
|
||||
@Synchronized
|
||||
fun pruneExpired() {
|
||||
val cutoff = nowMs() - retentionMs
|
||||
|
||||
@@ -27,23 +27,17 @@ object SourceHealth {
|
||||
private val _wifi = MutableStateFlow(Health())
|
||||
private val _deflock = MutableStateFlow(Health())
|
||||
private val _citizen = MutableStateFlow(Health())
|
||||
private val _waze = MutableStateFlow(Health())
|
||||
private val _mic = MutableStateFlow(Health())
|
||||
|
||||
val ble: StateFlow<Health> = _ble.asStateFlow()
|
||||
val wifi: StateFlow<Health> = _wifi.asStateFlow()
|
||||
val deflock: StateFlow<Health> = _deflock.asStateFlow()
|
||||
val citizen: StateFlow<Health> = _citizen.asStateFlow()
|
||||
val waze: StateFlow<Health> = _waze.asStateFlow()
|
||||
val mic: StateFlow<Health> = _mic.asStateFlow()
|
||||
|
||||
fun flowFor(source: DetectionSource): StateFlow<Health> = when (source) {
|
||||
DetectionSource.BLE -> ble
|
||||
DetectionSource.WIFI -> wifi
|
||||
DetectionSource.DEFLOCK -> deflock
|
||||
DetectionSource.CITIZEN -> citizen
|
||||
DetectionSource.WAZE -> waze
|
||||
DetectionSource.MIC -> mic
|
||||
}
|
||||
|
||||
fun record(source: DetectionSource, ok: Boolean, message: String? = null) {
|
||||
@@ -52,8 +46,6 @@ object SourceHealth {
|
||||
DetectionSource.WIFI -> _wifi
|
||||
DetectionSource.DEFLOCK -> _deflock
|
||||
DetectionSource.CITIZEN -> _citizen
|
||||
DetectionSource.WAZE -> _waze
|
||||
DetectionSource.MIC -> _mic
|
||||
}
|
||||
target.value = Health(
|
||||
status = if (ok) Status.OK else Status.FAILED,
|
||||
@@ -67,7 +59,5 @@ object SourceHealth {
|
||||
_wifi.value = Health()
|
||||
_deflock.value = Health()
|
||||
_citizen.value = Health()
|
||||
_waze.value = Health()
|
||||
_mic.value = Health()
|
||||
}
|
||||
}
|
||||
|
||||
@@ -21,4 +21,4 @@ enum class ThreatLevel(val minScore: Int) {
|
||||
}
|
||||
|
||||
/** Logical signal channel — used in the drill-down UI. */
|
||||
enum class DetectionSource { BLE, WIFI, DEFLOCK, CITIZEN, WAZE, MIC }
|
||||
enum class DetectionSource { BLE, WIFI, DEFLOCK, CITIZEN }
|
||||
|
||||
@@ -14,7 +14,6 @@ import android.os.Build
|
||||
import android.util.Log
|
||||
import androidx.core.content.ContextCompat
|
||||
import org.soulstone.overwatch.data.targets.BleOuis
|
||||
import org.soulstone.overwatch.data.targets.MicTargets
|
||||
import org.soulstone.overwatch.data.targets.Patterns
|
||||
import org.soulstone.overwatch.data.targets.RavenUuids
|
||||
import org.soulstone.overwatch.fusion.ConfidenceEngine
|
||||
@@ -39,9 +38,7 @@ import org.soulstone.overwatch.fusion.SourceHealth
|
||||
class BleScanner(
|
||||
private val context: Context,
|
||||
private val store: DetectionStore,
|
||||
private val rssi: RssiTracker = RssiTracker(),
|
||||
/** When true, also evaluate each scan against MicTargets and submit MIC events. */
|
||||
private val micEnabled: () -> Boolean = { false }
|
||||
private val rssi: RssiTracker = RssiTracker()
|
||||
) {
|
||||
|
||||
companion object {
|
||||
@@ -173,66 +170,35 @@ class BleScanner(
|
||||
}
|
||||
|
||||
// Cheap pre-filter — drop devices that have zero target signals.
|
||||
val isSurveillance = BleOuis.matches(mac) ||
|
||||
val candidate = BleOuis.matches(mac) ||
|
||||
Patterns.bleNameMatch(name) ||
|
||||
Patterns.isPenguinNumeric(name) ||
|
||||
RavenUuids.countMatches(advertisedUuids) > 0 ||
|
||||
companyId == org.soulstone.overwatch.data.targets.Manufacturers.XUNTONG_COMPANY_ID
|
||||
val isMic = micEnabled() &&
|
||||
MicTargets.couldBeMicBle(mac, name, advertisedUuids, companyId)
|
||||
if (!isSurveillance && !isMic) return
|
||||
if (!candidate) return
|
||||
|
||||
rssi.update(mac, result.rssi)
|
||||
val stationary = rssi.isStationary(mac)
|
||||
val obs = ConfidenceEngine.BleObservation(
|
||||
mac = mac,
|
||||
rssi = result.rssi,
|
||||
deviceName = name,
|
||||
advertisedUuids = advertisedUuids,
|
||||
manufacturerCompanyId = companyId,
|
||||
manufacturerPayload = payload,
|
||||
isStationary = rssi.isStationary(mac)
|
||||
)
|
||||
val scored = ConfidenceEngine.scoreBle(obs)
|
||||
if (scored.score < ALARM_THRESHOLD) return
|
||||
|
||||
if (isSurveillance) {
|
||||
val obs = ConfidenceEngine.BleObservation(
|
||||
mac = mac,
|
||||
rssi = result.rssi,
|
||||
deviceName = name,
|
||||
advertisedUuids = advertisedUuids,
|
||||
manufacturerCompanyId = companyId,
|
||||
manufacturerPayload = payload,
|
||||
isStationary = stationary
|
||||
store.submit(
|
||||
DetectionEvent(
|
||||
source = DetectionSource.BLE,
|
||||
key = mac,
|
||||
label = scored.label,
|
||||
score = scored.score,
|
||||
matchedMethods = scored.methods,
|
||||
rssi = result.rssi
|
||||
)
|
||||
val scored = ConfidenceEngine.scoreBle(obs)
|
||||
if (scored.score >= ALARM_THRESHOLD) {
|
||||
store.submit(
|
||||
DetectionEvent(
|
||||
source = DetectionSource.BLE,
|
||||
key = mac,
|
||||
label = scored.label,
|
||||
score = scored.score,
|
||||
matchedMethods = scored.methods,
|
||||
rssi = result.rssi
|
||||
)
|
||||
)
|
||||
}
|
||||
}
|
||||
if (isMic) {
|
||||
val obs = ConfidenceEngine.MicBleObservation(
|
||||
mac = mac,
|
||||
rssi = result.rssi,
|
||||
deviceName = name,
|
||||
advertisedUuids = advertisedUuids,
|
||||
manufacturerCompanyId = companyId,
|
||||
isStationary = stationary
|
||||
)
|
||||
val scored = ConfidenceEngine.scoreMicBle(obs)
|
||||
if (scored.score >= ALARM_THRESHOLD) {
|
||||
store.submit(
|
||||
DetectionEvent(
|
||||
source = DetectionSource.MIC,
|
||||
// Disambiguate from any BLE event on the same MAC so the
|
||||
// store's (source, key) dedup doesn't collide.
|
||||
key = "mic:$mac",
|
||||
label = scored.label,
|
||||
score = scored.score,
|
||||
matchedMethods = scored.methods,
|
||||
rssi = result.rssi
|
||||
)
|
||||
)
|
||||
}
|
||||
}
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -99,36 +99,15 @@ class CitizenScanner(
|
||||
// Drop cache entries that no longer appear in the trending list (resolved).
|
||||
incidentCache.keys.retainAll(ids.toSet())
|
||||
|
||||
// Fetch any ids we haven't seen yet — Citizen incidents don't mutate,
|
||||
// so a single fetch per id per session is enough.
|
||||
for (id in ids) {
|
||||
if (incidentCache[id] == null) {
|
||||
client.fetchIncident(id)?.also { incidentCache[id] = it }
|
||||
}
|
||||
}
|
||||
|
||||
emitProximityEvents(fix, ids.mapNotNull { incidentCache[it] })
|
||||
}
|
||||
|
||||
/**
|
||||
* Re-evaluate the cached incident set against the current proximity + age
|
||||
* thresholds and the latest fix, *without* a network refetch. Used when
|
||||
* the user moves the proximity slider — events outside a tightened radius
|
||||
* would otherwise linger and detections inside a widened radius wouldn't
|
||||
* appear until the next poll cycle.
|
||||
*/
|
||||
fun refresh() {
|
||||
val fix = locationProvider.location.value ?: return
|
||||
store.clearSource(DetectionSource.CITIZEN)
|
||||
emitProximityEvents(fix, incidentCache.values.toList())
|
||||
}
|
||||
|
||||
private fun emitProximityEvents(fix: Location, incidents: Collection<CitizenClient.Incident>) {
|
||||
val now = System.currentTimeMillis()
|
||||
val limit = proximityMeters()
|
||||
val out = FloatArray(1)
|
||||
|
||||
for (incident in incidents) {
|
||||
for (id in ids) {
|
||||
val incident = incidentCache[id] ?: client.fetchIncident(id)?.also {
|
||||
incidentCache[id] = it
|
||||
} ?: continue
|
||||
|
||||
// Title-based pre-filter: drop pure fire/medical events.
|
||||
if (FIRE_MEDICAL_RX.containsMatchIn(incident.title) &&
|
||||
!POLICE_TITLE_RX.containsMatchIn(incident.title)) {
|
||||
|
||||
@@ -4,9 +4,6 @@ import android.location.Location
|
||||
import android.util.Log
|
||||
import kotlinx.coroutines.CoroutineScope
|
||||
import kotlinx.coroutines.Job
|
||||
import kotlinx.coroutines.flow.MutableStateFlow
|
||||
import kotlinx.coroutines.flow.StateFlow
|
||||
import kotlinx.coroutines.flow.asStateFlow
|
||||
import kotlinx.coroutines.flow.collectLatest
|
||||
import kotlinx.coroutines.launch
|
||||
import org.soulstone.overwatch.data.location.LocationProvider
|
||||
@@ -44,10 +41,7 @@ class DeflockScanner(
|
||||
private var lastFetchLon: Double? = null
|
||||
private var lastAttemptMs: Long = 0L
|
||||
private var lastAttemptOk: Boolean = false
|
||||
private val _cachedPoints = MutableStateFlow<List<DeflockClient.AlprPoint>>(emptyList())
|
||||
/** All ALPR points in the current cell — exposed so the UI map can render them.
|
||||
* Distinct from the proximity-filtered DetectionEvents on [DetectionStore]. */
|
||||
val cachedPoints: StateFlow<List<DeflockClient.AlprPoint>> = _cachedPoints.asStateFlow()
|
||||
private var cachedPoints: List<DeflockClient.AlprPoint> = emptyList()
|
||||
|
||||
fun start(scope: CoroutineScope): Boolean {
|
||||
if (job != null) return true
|
||||
@@ -67,7 +61,7 @@ class DeflockScanner(
|
||||
lastFetchLon = null
|
||||
lastAttemptMs = 0L
|
||||
lastAttemptOk = false
|
||||
_cachedPoints.value = emptyList()
|
||||
cachedPoints = emptyList()
|
||||
Log.i(TAG, "DeflockScanner stopped")
|
||||
}
|
||||
|
||||
@@ -80,12 +74,12 @@ class DeflockScanner(
|
||||
lastAttemptMs = System.currentTimeMillis()
|
||||
when (val result = client.fetchAround(fix.latitude, fix.longitude)) {
|
||||
is DeflockClient.FetchResult.Success -> {
|
||||
_cachedPoints.value = result.points
|
||||
cachedPoints = result.points
|
||||
lastAttemptOk = true
|
||||
SourceHealth.record(DetectionSource.DEFLOCK, ok = true)
|
||||
Log.i(
|
||||
TAG,
|
||||
"Loaded ${result.points.size} ALPRs around " +
|
||||
"Loaded ${cachedPoints.size} ALPRs around " +
|
||||
"(${fix.latitude}, ${fix.longitude})"
|
||||
)
|
||||
}
|
||||
@@ -101,33 +95,11 @@ class DeflockScanner(
|
||||
}
|
||||
}
|
||||
}
|
||||
emitProximityEvents(fix)
|
||||
}
|
||||
|
||||
/**
|
||||
* Re-evaluate the cached ALPRs against the current proximity threshold and
|
||||
* the latest fix, *without* a network refetch. Used when the user moves the
|
||||
* proximity slider — the slider changes [proximityMeters], but the scanner
|
||||
* is otherwise idle (no new location ticks while stationary), so events
|
||||
* outside the new radius would otherwise linger and detections inside the
|
||||
* widened radius wouldn't appear until the next handleFix cycle.
|
||||
*
|
||||
* Clears the DEFLOCK source from the store first so events that fall
|
||||
* outside a tightened radius disappear immediately.
|
||||
*/
|
||||
fun refresh() {
|
||||
val fix = locationProvider.location.value ?: return
|
||||
store.clearSource(DetectionSource.DEFLOCK)
|
||||
emitProximityEvents(fix)
|
||||
}
|
||||
|
||||
private fun emitProximityEvents(fix: Location) {
|
||||
val points = _cachedPoints.value
|
||||
if (points.isEmpty()) return
|
||||
if (cachedPoints.isEmpty()) return
|
||||
|
||||
val limit = proximityMeters()
|
||||
val out = FloatArray(1)
|
||||
for (p in points) {
|
||||
for (p in cachedPoints) {
|
||||
Location.distanceBetween(fix.latitude, fix.longitude, p.lat, p.lon, out)
|
||||
val dist = out[0]
|
||||
if (dist > limit) continue
|
||||
|
||||
@@ -1,225 +0,0 @@
|
||||
package org.soulstone.overwatch.scan
|
||||
|
||||
import android.util.Log
|
||||
import java.net.HttpURLConnection
|
||||
import java.net.URL
|
||||
import java.net.URLEncoder
|
||||
import java.time.Instant
|
||||
import java.time.LocalDateTime
|
||||
import java.time.ZoneOffset
|
||||
import kotlin.math.cos
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.withContext
|
||||
import org.json.JSONArray
|
||||
import org.json.JSONObject
|
||||
|
||||
/**
|
||||
* Fetches live Waze POLICE alerts through the OVERWATCH proxy at
|
||||
* `api.blackflagintel.com` (a Caddy vhost on the ASTROPHAGE box). The proxy
|
||||
* holds the real OpenWeb Ninja API key server-side and injects it; the app only
|
||||
* presents a scoped, revocable `X-App-Token`. So the valuable key never ships in
|
||||
* the APK — a leaked/decompiled build carries only the proxy token, which works
|
||||
* against this one endpoint and can be rotated on the server in seconds.
|
||||
*
|
||||
* GET https://api.blackflagintel.com/waze/alerts-and-jams
|
||||
* ?bottom_left=<minLat>,<minLon>&top_right=<maxLat>,<maxLon>&max_alerts=200
|
||||
* Header: X-App-Token: <token from encrypted Settings, never baked into the APK>
|
||||
*
|
||||
* The token is entered once in Settings and stored encrypted (see [SecureStore]);
|
||||
* an empty token means the source is unconfigured — [isConfigured] is false and
|
||||
* the scanner surfaces that instead of calling out.
|
||||
*
|
||||
* Two verified quirks of the upstream feed drive the request/parse shape:
|
||||
* - It echoes but does NOT honor an `alert_types` filter, and defaults to
|
||||
* `max_alerts=20`, so POLICE reports get crowded out by HAZARD/ROAD_CLOSED.
|
||||
* We pull the full page (200 = server ceiling) and filter to POLICE here.
|
||||
* - Response envelope is `{ "data": { "alerts": [...], "jams": [...] } }`;
|
||||
* each alert carries `alert_id`, `type`, `subtype` (nullable), `latitude`,
|
||||
* `longitude`, `alert_confidence` (0-5), `alert_reliability` (0-10), and an
|
||||
* ISO-8601 `publish_datetime_utc`. The parser also accepts Waze-native names
|
||||
* (`location.y`/`confidence`/`pubMillis`) so a minor upstream change to the
|
||||
* shape doesn't silently zero out detections.
|
||||
*/
|
||||
class WazeClient(
|
||||
private val appToken: () -> String = { "" }
|
||||
) {
|
||||
|
||||
companion object {
|
||||
private const val TAG = "WazeClient"
|
||||
private const val BASE = "https://api.blackflagintel.com/waze/alerts-and-jams"
|
||||
private const val TIMEOUT_MS = 10_000
|
||||
|
||||
/** Never sweep a box tighter than this, so alerts the user is driving
|
||||
* toward are already fetched by the time the precise proximity filter
|
||||
* (applied in the scanner) starts including them. */
|
||||
private const val BBOX_MIN_RADIUS_M = 800.0
|
||||
}
|
||||
|
||||
/** True when a proxy token is set. False → source is unconfigured. */
|
||||
val isConfigured: Boolean get() = appToken().isNotBlank()
|
||||
|
||||
data class Alert(
|
||||
val uuid: String,
|
||||
val subtype: String?,
|
||||
val lat: Double,
|
||||
val lon: Double,
|
||||
val pubMillis: Long,
|
||||
val confidence: Int, // 0-5
|
||||
val reliability: Int // 0-10
|
||||
)
|
||||
|
||||
/** Outcome — distinguishes "no police alerts in area" from "couldn't reach the feed." */
|
||||
sealed class FetchResult {
|
||||
data class Success(val alerts: List<Alert>) : FetchResult()
|
||||
data class Failed(val reason: String) : FetchResult()
|
||||
}
|
||||
|
||||
suspend fun fetchPoliceNear(
|
||||
lat: Double,
|
||||
lon: Double,
|
||||
radiusMeters: Float
|
||||
): FetchResult = withContext(Dispatchers.IO) {
|
||||
if (!isConfigured) return@withContext FetchResult.Failed("Proxy token not set")
|
||||
|
||||
val r = radiusMeters.toDouble().coerceAtLeast(BBOX_MIN_RADIUS_M)
|
||||
val latDelta = r / 111_000.0
|
||||
val lonDelta = r / (111_000.0 * cos(Math.toRadians(lat)).coerceAtLeast(0.01))
|
||||
// Double.toString() is locale-independent (always '.'), so string-building
|
||||
// the coordinates avoids any comma-decimal-separator surprise.
|
||||
val bottomLeft = "${lat - latDelta},${lon - lonDelta}"
|
||||
val topRight = "${lat + latDelta},${lon + lonDelta}"
|
||||
// max_alerts=200 (the server ceiling), not an alert_types filter — see
|
||||
// the class KDoc. The proximity-sized bbox keeps the real alert count
|
||||
// well under 200, so POLICE entries are never truncated away.
|
||||
val url = URL(
|
||||
"$BASE?bottom_left=${enc(bottomLeft)}&top_right=${enc(topRight)}&max_alerts=200"
|
||||
)
|
||||
|
||||
val conn = (url.openConnection() as HttpURLConnection).apply {
|
||||
connectTimeout = TIMEOUT_MS
|
||||
readTimeout = TIMEOUT_MS
|
||||
requestMethod = "GET"
|
||||
setRequestProperty("X-App-Token", appToken())
|
||||
setRequestProperty("Accept", "application/json")
|
||||
}
|
||||
try {
|
||||
when (val code = conn.responseCode) {
|
||||
in 200..299 -> {
|
||||
val body = conn.inputStream.bufferedReader().use { it.readText() }
|
||||
FetchResult.Success(parsePolice(body))
|
||||
}
|
||||
401, 403 -> {
|
||||
Log.w(TAG, "Waze proxy rejected token ($code)")
|
||||
FetchResult.Failed("Proxy rejected token (HTTP $code)")
|
||||
}
|
||||
429 -> {
|
||||
Log.w(TAG, "Waze feed rate-limited (429)")
|
||||
FetchResult.Failed("Rate limited (HTTP 429)")
|
||||
}
|
||||
else -> {
|
||||
Log.w(TAG, "Waze feed returned $code")
|
||||
FetchResult.Failed("HTTP $code")
|
||||
}
|
||||
}
|
||||
} catch (e: Exception) {
|
||||
Log.w(TAG, "Waze feed fetch failed: ${e.message}")
|
||||
FetchResult.Failed(e.message ?: e.javaClass.simpleName)
|
||||
} finally {
|
||||
conn.disconnect()
|
||||
}
|
||||
}
|
||||
|
||||
private fun parsePolice(body: String): List<Alert> {
|
||||
if (body.isBlank()) return emptyList()
|
||||
return try {
|
||||
val alerts = extractAlerts(JSONObject(body)) ?: return emptyList()
|
||||
val out = ArrayList<Alert>(alerts.length())
|
||||
for (i in 0 until alerts.length()) {
|
||||
val a = alerts.optJSONObject(i) ?: continue
|
||||
|
||||
// We request alert_types=POLICE server-side; this is a belt-and-
|
||||
// suspenders guard in case the envelope also carries other types.
|
||||
val type = firstString(a, "type", "alertType")
|
||||
if (type != null && !type.equals("POLICE", ignoreCase = true)) continue
|
||||
|
||||
val loc = a.optJSONObject("location")
|
||||
val lat = doubleOrNull(a, "latitude") ?: loc?.let { doubleOrNull(it, "y") } ?: continue
|
||||
val lon = doubleOrNull(a, "longitude") ?: loc?.let { doubleOrNull(it, "x") } ?: continue
|
||||
if (lat.isNaN() || lon.isNaN()) continue
|
||||
|
||||
val uuid = firstString(a, "alert_id", "uuid", "id")
|
||||
?: "$lat,$lon,${firstLong(a, "publish_datetime_utc") ?: i}"
|
||||
|
||||
out.add(
|
||||
Alert(
|
||||
uuid = uuid,
|
||||
subtype = firstString(a, "subtype"),
|
||||
lat = lat,
|
||||
lon = lon,
|
||||
pubMillis = parseTimeMillis(a),
|
||||
confidence = firstInt(a, "alert_confidence", "confidence") ?: 0,
|
||||
reliability = firstInt(a, "alert_reliability", "reliability") ?: 0
|
||||
)
|
||||
)
|
||||
}
|
||||
out
|
||||
} catch (e: Exception) {
|
||||
Log.w(TAG, "Failed to parse Waze feed response: ${e.message}")
|
||||
emptyList()
|
||||
}
|
||||
}
|
||||
|
||||
/** Locate the alerts array across the known envelope variants. */
|
||||
private fun extractAlerts(root: JSONObject): JSONArray? {
|
||||
root.optJSONArray("alerts")?.let { return it }
|
||||
when (val data = root.opt("data")) {
|
||||
is JSONArray -> return data
|
||||
is JSONObject -> data.optJSONArray("alerts")?.let { return it }
|
||||
}
|
||||
root.optJSONObject("result")?.optJSONArray("alerts")?.let { return it }
|
||||
return null
|
||||
}
|
||||
|
||||
/** publish_datetime_utc is an ISO-8601 string; fall back to epoch-millis
|
||||
* fields, then to "now" so a missing timestamp never drops an alert. */
|
||||
private fun parseTimeMillis(a: JSONObject): Long {
|
||||
val iso = firstString(a, "publish_datetime_utc", "pub_datetime_utc")
|
||||
if (iso != null) {
|
||||
try {
|
||||
return Instant.parse(iso).toEpochMilli()
|
||||
} catch (_: Exception) {
|
||||
try {
|
||||
return LocalDateTime.parse(iso.replace(' ', 'T'))
|
||||
.toInstant(ZoneOffset.UTC).toEpochMilli()
|
||||
} catch (_: Exception) { /* fall through */ }
|
||||
}
|
||||
}
|
||||
return firstLong(a, "pubMillis", "pub_millis") ?: System.currentTimeMillis()
|
||||
}
|
||||
|
||||
private fun enc(s: String): String = URLEncoder.encode(s, "UTF-8")
|
||||
|
||||
private fun firstString(o: JSONObject, vararg keys: String): String? {
|
||||
for (k in keys) {
|
||||
val v = o.optString(k, "")
|
||||
if (v.isNotBlank() && v != "null") return v
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
private fun doubleOrNull(o: JSONObject, key: String): Double? {
|
||||
if (!o.has(key) || o.isNull(key)) return null
|
||||
val v = o.optDouble(key, Double.NaN)
|
||||
return if (v.isNaN()) null else v
|
||||
}
|
||||
|
||||
private fun firstInt(o: JSONObject, vararg keys: String): Int? {
|
||||
for (k in keys) if (o.has(k) && !o.isNull(k)) return o.optInt(k, 0)
|
||||
return null
|
||||
}
|
||||
|
||||
private fun firstLong(o: JSONObject, vararg keys: String): Long? {
|
||||
for (k in keys) if (o.has(k) && !o.isNull(k)) return o.optLong(k, 0L)
|
||||
return null
|
||||
}
|
||||
}
|
||||
@@ -1,155 +0,0 @@
|
||||
package org.soulstone.overwatch.scan
|
||||
|
||||
import android.location.Location
|
||||
import android.util.Log
|
||||
import kotlinx.coroutines.CoroutineScope
|
||||
import kotlinx.coroutines.Job
|
||||
import kotlinx.coroutines.delay
|
||||
import kotlinx.coroutines.flow.first
|
||||
import kotlinx.coroutines.isActive
|
||||
import kotlinx.coroutines.launch
|
||||
import org.soulstone.overwatch.data.location.LocationProvider
|
||||
import org.soulstone.overwatch.fusion.ConfidenceEngine
|
||||
import org.soulstone.overwatch.fusion.DetectionEvent
|
||||
import org.soulstone.overwatch.fusion.DetectionSource
|
||||
import org.soulstone.overwatch.fusion.DetectionStore
|
||||
import org.soulstone.overwatch.fusion.SourceHealth
|
||||
|
||||
/**
|
||||
* Polls the OpenWeb Ninja Waze feed for live POLICE alerts around the current
|
||||
* location, then submits any inside [proximityMeters] and younger than
|
||||
* [MAX_AGE_MS].
|
||||
*
|
||||
* Poll cadence is deliberately slow — the feed is a metered paid API and lags
|
||||
* live Waze by ~20 min anyway, so a 4-min poll loses nothing and keeps request
|
||||
* volume (and pay-as-you-go cost, ~$0.005/req) low at ~15 req/active-hour. Kept
|
||||
* just under the DetectionStore's 5-min retention so a persistent alert (a
|
||||
* standing checkpoint) is re-submitted before it can expire and flicker out. If
|
||||
* no API key is configured the loop records the source as unreachable (with a
|
||||
* clear reason) and skips the network call rather than hammering a 401.
|
||||
*
|
||||
* The last fetched alert set is cached so [refresh] can re-evaluate against a
|
||||
* moved proximity slider without a network refetch (mirrors CitizenScanner).
|
||||
*/
|
||||
class WazeScanner(
|
||||
private val store: DetectionStore,
|
||||
private val locationProvider: LocationProvider,
|
||||
private val client: WazeClient = WazeClient(),
|
||||
private val proximityMeters: () -> Float = { 500f }
|
||||
) {
|
||||
|
||||
companion object {
|
||||
private const val TAG = "WazeScanner"
|
||||
private const val POLL_INTERVAL_MS = 240_000L
|
||||
// The hosted feed only lists still-active alerts but lags live Waze, so
|
||||
// real police sightings routinely arrive already 20-30 min old. A 10-min
|
||||
// cutoff (fine for the old direct-live feed) would drop nearly all of
|
||||
// them; 45 min matches what the feed actually serves as "current."
|
||||
private const val MAX_AGE_MS = 45L * 60L * 1000L
|
||||
}
|
||||
|
||||
private var job: Job? = null
|
||||
private var lastAlerts: List<WazeClient.Alert> = emptyList()
|
||||
|
||||
fun start(scope: CoroutineScope): Boolean {
|
||||
if (job != null) return true
|
||||
job = scope.launch {
|
||||
// Wait for the first fix so the opening poll fires as soon as we have
|
||||
// a location instead of after a full interval.
|
||||
locationProvider.location.first { it != null }
|
||||
while (isActive) {
|
||||
val fix = locationProvider.location.value
|
||||
if (fix != null) pollOnce(fix)
|
||||
delay(POLL_INTERVAL_MS)
|
||||
}
|
||||
}
|
||||
Log.i(TAG, "WazeScanner started (interval=${POLL_INTERVAL_MS}ms, configured=${client.isConfigured})")
|
||||
return true
|
||||
}
|
||||
|
||||
fun stop() {
|
||||
job?.cancel()
|
||||
job = null
|
||||
lastAlerts = emptyList()
|
||||
Log.i(TAG, "WazeScanner stopped")
|
||||
}
|
||||
|
||||
private suspend fun pollOnce(fix: Location) {
|
||||
if (!client.isConfigured) {
|
||||
SourceHealth.record(
|
||||
DetectionSource.WAZE,
|
||||
ok = false,
|
||||
message = "Proxy token not set — add it in Settings"
|
||||
)
|
||||
return
|
||||
}
|
||||
|
||||
when (val result = client.fetchPoliceNear(fix.latitude, fix.longitude, proximityMeters())) {
|
||||
is WazeClient.FetchResult.Failed -> {
|
||||
SourceHealth.record(
|
||||
DetectionSource.WAZE,
|
||||
ok = false,
|
||||
message = "Waze feed unreachable: ${result.reason}"
|
||||
)
|
||||
}
|
||||
is WazeClient.FetchResult.Success -> {
|
||||
SourceHealth.record(DetectionSource.WAZE, ok = true)
|
||||
lastAlerts = result.alerts
|
||||
// Deliberately no clearSource() here: re-submitting refreshes
|
||||
// still-present alerts by key (dedup) and lets vanished ones age
|
||||
// out via the store's 5-min TTL. Clearing every poll would briefly
|
||||
// drop the tier and re-raise it, double-firing the escalation
|
||||
// vibration each cycle. (Mirrors CitizenScanner.)
|
||||
emitProximityEvents(fix, result.alerts)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Re-evaluate the last fetched alert set against the current proximity + age
|
||||
* thresholds and latest fix, without a network refetch. Used when the user
|
||||
* moves the Waze proximity slider.
|
||||
*/
|
||||
fun refresh() {
|
||||
val fix = locationProvider.location.value ?: return
|
||||
store.clearSource(DetectionSource.WAZE)
|
||||
emitProximityEvents(fix, lastAlerts)
|
||||
}
|
||||
|
||||
private fun emitProximityEvents(fix: Location, alerts: List<WazeClient.Alert>) {
|
||||
val now = System.currentTimeMillis()
|
||||
val limit = proximityMeters()
|
||||
val out = FloatArray(1)
|
||||
|
||||
for (a in alerts) {
|
||||
val age = now - a.pubMillis
|
||||
if (age > MAX_AGE_MS) continue
|
||||
Location.distanceBetween(fix.latitude, fix.longitude, a.lat, a.lon, out)
|
||||
val dist = out[0]
|
||||
if (dist > limit) continue
|
||||
|
||||
val scored = ConfidenceEngine.scoreWaze(
|
||||
ConfidenceEngine.WazeObservation(
|
||||
uuid = a.uuid,
|
||||
distanceMeters = dist,
|
||||
ageMs = age,
|
||||
confidence = a.confidence,
|
||||
reliability = a.reliability,
|
||||
subtype = a.subtype
|
||||
)
|
||||
)
|
||||
store.submit(
|
||||
DetectionEvent(
|
||||
source = DetectionSource.WAZE,
|
||||
key = "waze:${a.uuid}",
|
||||
label = scored.label,
|
||||
score = scored.score,
|
||||
matchedMethods = scored.methods,
|
||||
rssi = null,
|
||||
lat = a.lat,
|
||||
lon = a.lon
|
||||
)
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -17,7 +17,6 @@ import kotlinx.coroutines.Job
|
||||
import kotlinx.coroutines.delay
|
||||
import kotlinx.coroutines.isActive
|
||||
import kotlinx.coroutines.launch
|
||||
import org.soulstone.overwatch.data.targets.MicTargets
|
||||
import org.soulstone.overwatch.data.targets.Patterns
|
||||
import org.soulstone.overwatch.data.targets.WifiOuis
|
||||
import org.soulstone.overwatch.fusion.ConfidenceEngine
|
||||
@@ -41,9 +40,7 @@ import org.soulstone.overwatch.fusion.SourceHealth
|
||||
class WifiScanner(
|
||||
private val context: Context,
|
||||
private val store: DetectionStore,
|
||||
private val rssi: RssiTracker = RssiTracker(),
|
||||
/** When true, also evaluate each scan against MicTargets and submit MIC events. */
|
||||
private val micEnabled: () -> Boolean = { false }
|
||||
private val rssi: RssiTracker = RssiTracker()
|
||||
) {
|
||||
|
||||
companion object {
|
||||
@@ -170,51 +167,31 @@ class WifiScanner(
|
||||
val bssid = r.BSSID ?: continue
|
||||
val ssid = readSsid(r)
|
||||
|
||||
val isSurveillance = WifiOuis.matches(bssid) ||
|
||||
val candidate = WifiOuis.matches(bssid) ||
|
||||
Patterns.ssidGenericMatch(ssid) ||
|
||||
Patterns.ssidFlockFormat(ssid)
|
||||
val isMic = micEnabled() && MicTargets.couldBeMicWifi(bssid, ssid)
|
||||
if (!isSurveillance && !isMic) continue
|
||||
if (!candidate) continue
|
||||
|
||||
rssi.update(bssid, r.level)
|
||||
val stationary = rssi.isStationary(bssid)
|
||||
val obs = ConfidenceEngine.WifiObservation(
|
||||
bssid = bssid,
|
||||
ssid = ssid,
|
||||
rssi = r.level,
|
||||
isStationary = rssi.isStationary(bssid)
|
||||
)
|
||||
val scored = ConfidenceEngine.scoreWifi(obs)
|
||||
if (scored.score < ALARM_THRESHOLD) continue
|
||||
|
||||
if (isSurveillance) {
|
||||
val obs = ConfidenceEngine.WifiObservation(
|
||||
bssid = bssid, ssid = ssid, rssi = r.level, isStationary = stationary
|
||||
store.submit(
|
||||
DetectionEvent(
|
||||
source = DetectionSource.WIFI,
|
||||
key = bssid,
|
||||
label = scored.label,
|
||||
score = scored.score,
|
||||
matchedMethods = scored.methods,
|
||||
rssi = r.level
|
||||
)
|
||||
val scored = ConfidenceEngine.scoreWifi(obs)
|
||||
if (scored.score >= ALARM_THRESHOLD) {
|
||||
store.submit(
|
||||
DetectionEvent(
|
||||
source = DetectionSource.WIFI,
|
||||
key = bssid,
|
||||
label = scored.label,
|
||||
score = scored.score,
|
||||
matchedMethods = scored.methods,
|
||||
rssi = r.level
|
||||
)
|
||||
)
|
||||
}
|
||||
}
|
||||
if (isMic) {
|
||||
val obs = ConfidenceEngine.MicWifiObservation(
|
||||
bssid = bssid, ssid = ssid, rssi = r.level, isStationary = stationary
|
||||
)
|
||||
val scored = ConfidenceEngine.scoreMicWifi(obs)
|
||||
if (scored.score >= ALARM_THRESHOLD) {
|
||||
store.submit(
|
||||
DetectionEvent(
|
||||
source = DetectionSource.MIC,
|
||||
key = "mic:$bssid",
|
||||
label = scored.label,
|
||||
score = scored.score,
|
||||
matchedMethods = scored.methods,
|
||||
rssi = r.level
|
||||
)
|
||||
)
|
||||
}
|
||||
}
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -7,7 +7,6 @@ import android.app.PendingIntent
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
import android.content.pm.ServiceInfo
|
||||
import android.location.Location
|
||||
import android.os.Build
|
||||
import android.os.IBinder
|
||||
import android.os.VibrationEffect
|
||||
@@ -23,14 +22,12 @@ import kotlinx.coroutines.flow.MutableStateFlow
|
||||
import kotlinx.coroutines.flow.StateFlow
|
||||
import kotlinx.coroutines.flow.asStateFlow
|
||||
import kotlinx.coroutines.flow.combine
|
||||
import kotlinx.coroutines.flow.drop
|
||||
import kotlinx.coroutines.launch
|
||||
import org.soulstone.overwatch.MainActivity
|
||||
import org.soulstone.overwatch.R
|
||||
import org.soulstone.overwatch.data.location.LocationProvider
|
||||
import org.soulstone.overwatch.data.settings.Settings
|
||||
import org.soulstone.overwatch.fusion.DetectionEvent
|
||||
import org.soulstone.overwatch.fusion.DetectionSource
|
||||
import org.soulstone.overwatch.fusion.DetectionStore
|
||||
import org.soulstone.overwatch.fusion.SourceHealth
|
||||
import org.soulstone.overwatch.fusion.ThreatLevel
|
||||
@@ -38,9 +35,6 @@ import org.soulstone.overwatch.scan.BleScanner
|
||||
import org.soulstone.overwatch.scan.CitizenScanner
|
||||
import org.soulstone.overwatch.scan.DeflockClient
|
||||
import org.soulstone.overwatch.scan.DeflockScanner
|
||||
import org.soulstone.overwatch.scan.DeflockClient.AlprPoint
|
||||
import org.soulstone.overwatch.scan.WazeClient
|
||||
import org.soulstone.overwatch.scan.WazeScanner
|
||||
import org.soulstone.overwatch.scan.WifiScanner
|
||||
|
||||
/**
|
||||
@@ -73,15 +67,6 @@ class DetectionService : LifecycleService() {
|
||||
private val _running = MutableStateFlow(false)
|
||||
val running: StateFlow<Boolean> = _running.asStateFlow()
|
||||
|
||||
/** Latest ALPR cell cache — UI map renders these as pins. Mirrored from
|
||||
* the active DeflockScanner while the service is running; cleared on stop. */
|
||||
private val _mapPoints = MutableStateFlow<List<AlprPoint>>(emptyList())
|
||||
val mapPoints: StateFlow<List<AlprPoint>> = _mapPoints.asStateFlow()
|
||||
|
||||
/** Latest fused location fix — UI map centers on this. */
|
||||
private val _location = MutableStateFlow<Location?>(null)
|
||||
val location: StateFlow<Location?> = _location.asStateFlow()
|
||||
|
||||
fun start(context: Context) {
|
||||
val intent = Intent(context, DetectionService::class.java).apply {
|
||||
action = ACTION_START
|
||||
@@ -107,29 +92,20 @@ class DetectionService : LifecycleService() {
|
||||
private lateinit var locationProvider: LocationProvider
|
||||
private lateinit var deflockScanner: DeflockScanner
|
||||
private lateinit var citizenScanner: CitizenScanner
|
||||
private lateinit var wazeScanner: WazeScanner
|
||||
private lateinit var overlayManager: OverlayManager
|
||||
private var pruneJob: Job? = null
|
||||
private var observerJob: Job? = null
|
||||
private var mapPointsJob: Job? = null
|
||||
private var locationJob: Job? = null
|
||||
private var deflockProxJob: Job? = null
|
||||
private var citizenProxJob: Job? = null
|
||||
private var wazeProxJob: Job? = null
|
||||
private var overlayJob: Job? = null
|
||||
private var bleStarted = false
|
||||
private var wifiStarted = false
|
||||
private var deflockStarted = false
|
||||
private var citizenStarted = false
|
||||
private var wazeStarted = false
|
||||
/** Last threat tier the notification displayed; tracks upward transitions for vibration. */
|
||||
private var lastNotifiedTier: ThreatLevel = ThreatLevel.GREEN
|
||||
|
||||
override fun onCreate() {
|
||||
super.onCreate()
|
||||
settings = Settings.get(this)
|
||||
bleScanner = BleScanner(this, store, micEnabled = { settings.micEnabled.value })
|
||||
wifiScanner = WifiScanner(this, store, micEnabled = { settings.micEnabled.value })
|
||||
bleScanner = BleScanner(this, store)
|
||||
wifiScanner = WifiScanner(this, store)
|
||||
locationProvider = LocationProvider(this)
|
||||
deflockScanner = DeflockScanner(
|
||||
store, locationProvider, DeflockClient(this),
|
||||
@@ -139,18 +115,6 @@ class DetectionService : LifecycleService() {
|
||||
store, locationProvider,
|
||||
proximityMeters = { settings.citizenProximityM.value.toFloat() }
|
||||
)
|
||||
wazeScanner = WazeScanner(
|
||||
store, locationProvider,
|
||||
client = WazeClient(appToken = { settings.wazeProxyToken.value }),
|
||||
proximityMeters = { settings.wazeProximityM.value.toFloat() }
|
||||
)
|
||||
overlayManager = OverlayManager(
|
||||
context = this,
|
||||
// User dragged the bubble onto the X — flip the persisted toggle
|
||||
// so the setting and the bubble state stay aligned. The settings
|
||||
// collector below will call hide() again, but hide() is idempotent.
|
||||
onDismissed = { settings.setOverlayEnabled(false) }
|
||||
)
|
||||
createNotificationChannel()
|
||||
}
|
||||
|
||||
@@ -182,8 +146,7 @@ class DetectionService : LifecycleService() {
|
||||
wifiStarted = wifiScanner.start(lifecycleScope)
|
||||
if (!wifiStarted) Log.w(TAG, "WifiScanner.start() returned false (permission/adapter)")
|
||||
}
|
||||
val needsLocation = settings.deflockEnabled.value || settings.citizenEnabled.value ||
|
||||
settings.wazeEnabled.value
|
||||
val needsLocation = settings.deflockEnabled.value || settings.citizenEnabled.value
|
||||
if (needsLocation) {
|
||||
val locOk = locationProvider.start()
|
||||
if (!locOk) {
|
||||
@@ -195,13 +158,10 @@ class DetectionService : LifecycleService() {
|
||||
if (settings.citizenEnabled.value) {
|
||||
citizenScanner.start(lifecycleScope); citizenStarted = true
|
||||
}
|
||||
if (settings.wazeEnabled.value) {
|
||||
wazeScanner.start(lifecycleScope); wazeStarted = true
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
val anyStarted = bleStarted || wifiStarted || deflockStarted || citizenStarted || wazeStarted
|
||||
val anyStarted = bleStarted || wifiStarted || deflockStarted || citizenStarted
|
||||
if (!anyStarted) {
|
||||
Log.w(TAG, "No scanner started — endScanning + stopSelf")
|
||||
endScanning()
|
||||
@@ -209,20 +169,6 @@ class DetectionService : LifecycleService() {
|
||||
return
|
||||
}
|
||||
|
||||
// MIC piggybacks on the BLE/WiFi scanners. Surface its health so the
|
||||
// user sees an explicit status row rather than a silent UNKNOWN.
|
||||
if (settings.micEnabled.value) {
|
||||
if (bleStarted || wifiStarted) {
|
||||
SourceHealth.record(DetectionSource.MIC, ok = true)
|
||||
} else {
|
||||
SourceHealth.record(
|
||||
DetectionSource.MIC,
|
||||
ok = false,
|
||||
message = "Needs BLE or WiFi scanner enabled"
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
_running.value = true
|
||||
pruneJob?.cancel()
|
||||
pruneJob = lifecycleScope.launch {
|
||||
@@ -241,52 +187,6 @@ class DetectionService : LifecycleService() {
|
||||
onTierChanged(tier, top)
|
||||
}
|
||||
}
|
||||
|
||||
// Mirror scanner state to the companion StateFlows the UI observes.
|
||||
// These exist so the map widget doesn't need a direct handle on the
|
||||
// scanner instances (which are private to this service).
|
||||
mapPointsJob?.cancel()
|
||||
if (deflockStarted) {
|
||||
mapPointsJob = lifecycleScope.launch {
|
||||
deflockScanner.cachedPoints.collect { _mapPoints.value = it }
|
||||
}
|
||||
}
|
||||
locationJob?.cancel()
|
||||
locationJob = lifecycleScope.launch {
|
||||
locationProvider.location.collect { _location.value = it }
|
||||
}
|
||||
|
||||
// Live re-eval when the user moves a proximity slider. drop(1) skips
|
||||
// the StateFlow's initial replay so we don't redundantly clear+re-emit
|
||||
// the events the scanner just produced from its first handleFix call.
|
||||
deflockProxJob?.cancel()
|
||||
if (deflockStarted) {
|
||||
deflockProxJob = lifecycleScope.launch {
|
||||
settings.deflockProximityM.drop(1).collect { deflockScanner.refresh() }
|
||||
}
|
||||
}
|
||||
citizenProxJob?.cancel()
|
||||
if (citizenStarted) {
|
||||
citizenProxJob = lifecycleScope.launch {
|
||||
settings.citizenProximityM.drop(1).collect { citizenScanner.refresh() }
|
||||
}
|
||||
}
|
||||
wazeProxJob?.cancel()
|
||||
if (wazeStarted) {
|
||||
wazeProxJob = lifecycleScope.launch {
|
||||
settings.wazeProximityM.drop(1).collect { wazeScanner.refresh() }
|
||||
}
|
||||
}
|
||||
|
||||
// Floating threat-circle overlay — observe the toggle and show/hide
|
||||
// accordingly. The OverlayManager re-checks SYSTEM_ALERT_WINDOW each
|
||||
// show() so a denied/revoked permission silently no-ops.
|
||||
overlayJob?.cancel()
|
||||
overlayJob = lifecycleScope.launch {
|
||||
settings.overlayEnabled.collect { enabled ->
|
||||
if (enabled) overlayManager.show() else overlayManager.hide()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun endScanning() {
|
||||
@@ -298,21 +198,11 @@ class DetectionService : LifecycleService() {
|
||||
if (wifiStarted) { wifiScanner.stop(); wifiStarted = false }
|
||||
if (deflockStarted) { deflockScanner.stop(); deflockStarted = false }
|
||||
if (citizenStarted) { citizenScanner.stop(); citizenStarted = false }
|
||||
if (wazeStarted) { wazeScanner.stop(); wazeStarted = false }
|
||||
locationProvider.stop()
|
||||
store.clear()
|
||||
SourceHealth.reset()
|
||||
pruneJob?.cancel(); pruneJob = null
|
||||
observerJob?.cancel(); observerJob = null
|
||||
mapPointsJob?.cancel(); mapPointsJob = null
|
||||
locationJob?.cancel(); locationJob = null
|
||||
deflockProxJob?.cancel(); deflockProxJob = null
|
||||
citizenProxJob?.cancel(); citizenProxJob = null
|
||||
wazeProxJob?.cancel(); wazeProxJob = null
|
||||
overlayJob?.cancel(); overlayJob = null
|
||||
overlayManager.hide()
|
||||
_mapPoints.value = emptyList()
|
||||
_location.value = null
|
||||
lastNotifiedTier = ThreatLevel.GREEN
|
||||
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
|
||||
stopForeground(STOP_FOREGROUND_REMOVE)
|
||||
|
||||
@@ -1,330 +0,0 @@
|
||||
package org.soulstone.overwatch.service
|
||||
|
||||
import android.annotation.SuppressLint
|
||||
import android.content.Context
|
||||
import android.content.Intent
|
||||
import android.graphics.Canvas
|
||||
import android.graphics.Paint
|
||||
import android.graphics.PixelFormat
|
||||
import android.provider.Settings
|
||||
import android.util.Log
|
||||
import android.view.Gravity
|
||||
import android.view.MotionEvent
|
||||
import android.view.View
|
||||
import android.view.ViewGroup
|
||||
import android.view.WindowManager
|
||||
import android.widget.FrameLayout
|
||||
import androidx.compose.ui.platform.ComposeView
|
||||
import androidx.lifecycle.Lifecycle
|
||||
import androidx.lifecycle.LifecycleRegistry
|
||||
import androidx.lifecycle.setViewTreeLifecycleOwner
|
||||
import androidx.savedstate.SavedStateRegistry
|
||||
import androidx.savedstate.SavedStateRegistryController
|
||||
import androidx.savedstate.SavedStateRegistryOwner
|
||||
import androidx.savedstate.setViewTreeSavedStateRegistryOwner
|
||||
import kotlin.math.abs
|
||||
import kotlin.math.sqrt
|
||||
import org.soulstone.overwatch.MainActivity
|
||||
import org.soulstone.overwatch.ui.OverlayBubble
|
||||
|
||||
/**
|
||||
* Owns the floating threat-circle bubble — a [ComposeView] hosted in a
|
||||
* [WindowManager] window at TYPE_APPLICATION_OVERLAY.
|
||||
*
|
||||
* Touch model:
|
||||
* - The bubble window has FLAG_NOT_FOCUSABLE | FLAG_NOT_TOUCH_MODAL, so
|
||||
* touches outside the bubble pass through to whatever app is underneath
|
||||
* and the bubble never steals IME focus.
|
||||
* - Touches *inside* the bubble are intercepted by [TouchInterceptor], a
|
||||
* FrameLayout wrapper whose onInterceptTouchEvent always returns true.
|
||||
* Without that wrapper the inner osmdroid MapView consumes ACTION_DOWN
|
||||
* for its own pan handling and the OnTouchListener never sees the gesture.
|
||||
* - Drag updates the window LayoutParams via WindowManager.updateViewLayout.
|
||||
* - Tap (movement under TAP_SLOP_PX) launches MainActivity.
|
||||
*
|
||||
* Dismiss zone:
|
||||
* - When the user begins dragging, a separate WindowManager view ([DismissView])
|
||||
* appears at bottom-center showing an X. The bubble's screen-space center
|
||||
* is checked against the X's bounds on each MOVE; on UP, if the bubble was
|
||||
* released over the X, [onDismissed] fires (caller flips the setting off
|
||||
* so the toggle and the bubble state stay in sync).
|
||||
* - The dismiss zone uses FLAG_NOT_TOUCHABLE so it never steals the gesture
|
||||
* — it's purely visual feedback.
|
||||
*/
|
||||
class OverlayManager(
|
||||
private val context: Context,
|
||||
private val onDismissed: () -> Unit
|
||||
) {
|
||||
|
||||
private companion object {
|
||||
private const val TAG = "OverlayManager"
|
||||
private const val INITIAL_X_DP = 24
|
||||
private const val INITIAL_Y_DP = 120
|
||||
private const val TAP_SLOP_PX = 12
|
||||
private const val BUBBLE_SIZE_DP = 140
|
||||
private const val DISMISS_SIZE_DP = 88
|
||||
private const val DISMISS_BOTTOM_MARGIN_DP = 100
|
||||
/** Extra slop around the dismiss zone — released within this radius
|
||||
* counts as "dropped on X". */
|
||||
private const val DISMISS_HIT_SLOP_DP = 16
|
||||
}
|
||||
|
||||
private val wm: WindowManager =
|
||||
context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
|
||||
private val density = context.resources.displayMetrics.density
|
||||
private val bubbleSizePx = (BUBBLE_SIZE_DP * density).toInt()
|
||||
|
||||
private var container: TouchInterceptor? = null
|
||||
private var owner: OverlayOwner? = null
|
||||
private var params: WindowManager.LayoutParams? = null
|
||||
|
||||
private var dismissView: DismissView? = null
|
||||
private var dismissCenterX = 0f
|
||||
private var dismissCenterY = 0f
|
||||
private var dismissHitRadius = 0f
|
||||
|
||||
fun show() {
|
||||
if (container != null) return
|
||||
if (!Settings.canDrawOverlays(context)) {
|
||||
Log.i(TAG, "Overlay permission not granted; skipping show()")
|
||||
return
|
||||
}
|
||||
|
||||
val newOwner = OverlayOwner()
|
||||
val composeView = ComposeView(context).apply {
|
||||
setContent { OverlayBubble() }
|
||||
}
|
||||
// Wrap so we can intercept *before* MapView's own touch handling.
|
||||
// Compose's WindowRecomposer reads findViewTreeLifecycleOwner from
|
||||
// the *window-root* view (= the wrapper here, since it's what's
|
||||
// attached to WindowManager). Setting the owner only on the inner
|
||||
// ComposeView throws IllegalStateException at composition startup —
|
||||
// that was the v0.3.1 crash.
|
||||
val wrapper = TouchInterceptor(context).apply {
|
||||
setViewTreeLifecycleOwner(newOwner)
|
||||
setViewTreeSavedStateRegistryOwner(newOwner)
|
||||
addView(
|
||||
composeView,
|
||||
FrameLayout.LayoutParams(
|
||||
ViewGroup.LayoutParams.WRAP_CONTENT,
|
||||
ViewGroup.LayoutParams.WRAP_CONTENT
|
||||
)
|
||||
)
|
||||
}
|
||||
|
||||
val lp = WindowManager.LayoutParams(
|
||||
WindowManager.LayoutParams.WRAP_CONTENT,
|
||||
WindowManager.LayoutParams.WRAP_CONTENT,
|
||||
WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY,
|
||||
WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE or
|
||||
WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL,
|
||||
PixelFormat.TRANSLUCENT
|
||||
).apply {
|
||||
gravity = Gravity.TOP or Gravity.START
|
||||
x = (INITIAL_X_DP * density).toInt()
|
||||
y = (INITIAL_Y_DP * density).toInt()
|
||||
}
|
||||
|
||||
wrapper.setOnTouchListener(DragHandler(lp))
|
||||
|
||||
try {
|
||||
wm.addView(wrapper, lp)
|
||||
container = wrapper
|
||||
owner = newOwner
|
||||
params = lp
|
||||
Log.i(TAG, "Overlay bubble attached")
|
||||
} catch (e: Exception) {
|
||||
Log.w(TAG, "Failed to attach overlay: ${e.message}")
|
||||
newOwner.destroy()
|
||||
}
|
||||
}
|
||||
|
||||
fun hide() {
|
||||
val v = container ?: return
|
||||
try { wm.removeView(v) } catch (e: Exception) {
|
||||
Log.w(TAG, "removeView failed: ${e.message}")
|
||||
}
|
||||
owner?.destroy()
|
||||
container = null
|
||||
owner = null
|
||||
params = null
|
||||
hideDismissZone()
|
||||
Log.i(TAG, "Overlay bubble detached")
|
||||
}
|
||||
|
||||
private fun showDismissZone() {
|
||||
if (dismissView != null) return
|
||||
val sizePx = (DISMISS_SIZE_DP * density).toInt()
|
||||
val marginPx = (DISMISS_BOTTOM_MARGIN_DP * density).toInt()
|
||||
|
||||
// Precompute screen-space center so MOVE checks don't traverse the
|
||||
// view tree on every frame. Use displayMetrics (sufficient — a real
|
||||
// multi-display split would need WindowManager#getCurrentWindowMetrics
|
||||
// on API 30+, but the bubble lives on the user's primary display).
|
||||
val dm = context.resources.displayMetrics
|
||||
dismissCenterX = dm.widthPixels / 2f
|
||||
dismissCenterY = dm.heightPixels - marginPx - sizePx / 2f
|
||||
dismissHitRadius = sizePx / 2f + DISMISS_HIT_SLOP_DP * density
|
||||
|
||||
val v = DismissView(context)
|
||||
val lp = WindowManager.LayoutParams(
|
||||
sizePx, sizePx,
|
||||
WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY,
|
||||
WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE or
|
||||
WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL or
|
||||
WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE,
|
||||
PixelFormat.TRANSLUCENT
|
||||
).apply {
|
||||
gravity = Gravity.BOTTOM or Gravity.CENTER_HORIZONTAL
|
||||
y = marginPx
|
||||
}
|
||||
try {
|
||||
wm.addView(v, lp)
|
||||
dismissView = v
|
||||
} catch (e: Exception) {
|
||||
Log.w(TAG, "Failed to attach dismiss zone: ${e.message}")
|
||||
}
|
||||
}
|
||||
|
||||
private fun hideDismissZone() {
|
||||
val v = dismissView ?: return
|
||||
try { wm.removeView(v) } catch (_: Exception) {}
|
||||
dismissView = null
|
||||
}
|
||||
|
||||
private fun isOverDismiss(bubbleX: Int, bubbleY: Int): Boolean {
|
||||
if (dismissView == null) return false
|
||||
val cx = bubbleX + bubbleSizePx / 2f
|
||||
val cy = bubbleY + bubbleSizePx / 2f
|
||||
val dx = cx - dismissCenterX
|
||||
val dy = cy - dismissCenterY
|
||||
return sqrt((dx * dx + dy * dy).toDouble()) < dismissHitRadius
|
||||
}
|
||||
|
||||
/** Drag with raw coords; tap if movement stayed under [TAP_SLOP_PX]. */
|
||||
private inner class DragHandler(private val lp: WindowManager.LayoutParams) :
|
||||
View.OnTouchListener {
|
||||
|
||||
private var startX = 0
|
||||
private var startY = 0
|
||||
private var touchDownX = 0f
|
||||
private var touchDownY = 0f
|
||||
private var moved = false
|
||||
|
||||
@SuppressLint("ClickableViewAccessibility")
|
||||
override fun onTouch(v: View, ev: MotionEvent): Boolean {
|
||||
return when (ev.action) {
|
||||
MotionEvent.ACTION_DOWN -> {
|
||||
startX = lp.x
|
||||
startY = lp.y
|
||||
touchDownX = ev.rawX
|
||||
touchDownY = ev.rawY
|
||||
moved = false
|
||||
true
|
||||
}
|
||||
MotionEvent.ACTION_MOVE -> {
|
||||
val dx = ev.rawX - touchDownX
|
||||
val dy = ev.rawY - touchDownY
|
||||
if (!moved && (abs(dx) > TAP_SLOP_PX || abs(dy) > TAP_SLOP_PX)) {
|
||||
moved = true
|
||||
showDismissZone()
|
||||
}
|
||||
if (moved) {
|
||||
lp.x = startX + dx.toInt()
|
||||
lp.y = startY + dy.toInt()
|
||||
try { wm.updateViewLayout(v, lp) } catch (_: Exception) {}
|
||||
dismissView?.setHighlighted(isOverDismiss(lp.x, lp.y))
|
||||
}
|
||||
true
|
||||
}
|
||||
MotionEvent.ACTION_UP -> {
|
||||
if (moved && isOverDismiss(lp.x, lp.y)) {
|
||||
// Released on the X — tear down and signal the caller
|
||||
// so the persisted setting flips off too.
|
||||
hide()
|
||||
onDismissed()
|
||||
} else if (!moved) {
|
||||
// Tap → bring the host app forward.
|
||||
val intent = Intent(context, MainActivity::class.java).apply {
|
||||
flags = Intent.FLAG_ACTIVITY_NEW_TASK or
|
||||
Intent.FLAG_ACTIVITY_SINGLE_TOP
|
||||
}
|
||||
try { context.startActivity(intent) } catch (_: Exception) {}
|
||||
}
|
||||
hideDismissZone()
|
||||
true
|
||||
}
|
||||
MotionEvent.ACTION_CANCEL -> {
|
||||
hideDismissZone()
|
||||
true
|
||||
}
|
||||
else -> false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** Always-claiming wrapper. Without this, the osmdroid MapView descendant
|
||||
* consumes ACTION_DOWN for pan handling and the OnTouchListener never
|
||||
* fires — drags pan the map instead of moving the bubble. */
|
||||
private class TouchInterceptor(context: Context) : FrameLayout(context) {
|
||||
override fun onInterceptTouchEvent(ev: MotionEvent): Boolean = true
|
||||
}
|
||||
|
||||
/** Bottom-center dismiss target — translucent dark circle with a white X
|
||||
* that flips red when the bubble is hovering over it. Drawn manually so
|
||||
* we don't need to ship a vector resource for one-off use. */
|
||||
private class DismissView(context: Context) : View(context) {
|
||||
private val bg = Paint(Paint.ANTI_ALIAS_FLAG)
|
||||
private val xStroke = Paint(Paint.ANTI_ALIAS_FLAG).apply {
|
||||
color = 0xFFFFFFFF.toInt()
|
||||
strokeWidth = 8f
|
||||
style = Paint.Style.STROKE
|
||||
strokeCap = Paint.Cap.ROUND
|
||||
}
|
||||
private var highlighted = false
|
||||
|
||||
fun setHighlighted(value: Boolean) {
|
||||
if (highlighted != value) {
|
||||
highlighted = value
|
||||
invalidate()
|
||||
}
|
||||
}
|
||||
|
||||
override fun onDraw(canvas: Canvas) {
|
||||
val cx = width / 2f
|
||||
val cy = height / 2f
|
||||
val r = minOf(cx, cy)
|
||||
bg.color = if (highlighted) 0xDDD7263D.toInt() else 0xCC1A1A1A.toInt()
|
||||
canvas.drawCircle(cx, cy, r - 4f, bg)
|
||||
val inset = r * 0.35f
|
||||
canvas.drawLine(cx - inset, cy - inset, cx + inset, cy + inset, xStroke)
|
||||
canvas.drawLine(cx + inset, cy - inset, cx - inset, cy + inset, xStroke)
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Compose's [ComposeView] requires both a LifecycleOwner and a
|
||||
* [SavedStateRegistryOwner] in its view tree. A bare Service isn't an SSR
|
||||
* owner, so we synthesize one bound to the bubble's lifetime. The
|
||||
* lifecycle is forced to RESUMED on construction (Compose only renders at
|
||||
* STARTED+) and DESTROYED on [destroy].
|
||||
*/
|
||||
private class OverlayOwner : SavedStateRegistryOwner {
|
||||
private val lifecycleReg = LifecycleRegistry(this)
|
||||
private val ssrController = SavedStateRegistryController.create(this)
|
||||
|
||||
init {
|
||||
ssrController.performAttach()
|
||||
ssrController.performRestore(null)
|
||||
lifecycleReg.currentState = Lifecycle.State.RESUMED
|
||||
}
|
||||
|
||||
override val lifecycle: Lifecycle get() = lifecycleReg
|
||||
override val savedStateRegistry: SavedStateRegistry
|
||||
get() = ssrController.savedStateRegistry
|
||||
|
||||
fun destroy() {
|
||||
lifecycleReg.currentState = Lifecycle.State.DESTROYED
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,15 +1,11 @@
|
||||
package org.soulstone.overwatch.ui
|
||||
|
||||
import android.content.Intent
|
||||
import android.location.Location
|
||||
import android.net.Uri
|
||||
import androidx.compose.animation.core.RepeatMode
|
||||
import androidx.compose.animation.core.animateFloat
|
||||
import androidx.compose.animation.core.infiniteRepeatable
|
||||
import androidx.compose.animation.core.rememberInfiniteTransition
|
||||
import androidx.compose.animation.core.tween
|
||||
import androidx.compose.foundation.background
|
||||
import androidx.compose.foundation.border
|
||||
import androidx.compose.foundation.clickable
|
||||
import androidx.compose.foundation.layout.Arrangement
|
||||
import androidx.compose.foundation.layout.Box
|
||||
@@ -23,6 +19,8 @@ import androidx.compose.foundation.layout.padding
|
||||
import androidx.compose.foundation.layout.size
|
||||
import androidx.compose.foundation.shape.CircleShape
|
||||
import androidx.compose.foundation.shape.RoundedCornerShape
|
||||
import android.content.Intent
|
||||
import android.net.Uri
|
||||
import androidx.compose.material.icons.Icons
|
||||
import androidx.compose.material.icons.filled.Place
|
||||
import androidx.compose.material.icons.filled.Settings
|
||||
@@ -42,7 +40,6 @@ import androidx.compose.runtime.Composable
|
||||
import androidx.compose.runtime.collectAsState
|
||||
import androidx.compose.runtime.getValue
|
||||
import androidx.compose.runtime.mutableStateOf
|
||||
import androidx.compose.runtime.remember
|
||||
import androidx.compose.runtime.saveable.rememberSaveable
|
||||
import androidx.compose.runtime.setValue
|
||||
import androidx.compose.ui.Alignment
|
||||
@@ -54,18 +51,11 @@ import androidx.compose.ui.text.font.FontFamily
|
||||
import androidx.compose.ui.text.font.FontWeight
|
||||
import androidx.compose.ui.unit.dp
|
||||
import androidx.compose.ui.unit.sp
|
||||
import androidx.compose.ui.viewinterop.AndroidView
|
||||
import kotlin.math.cos
|
||||
import org.osmdroid.tileprovider.tilesource.TileSourceFactory
|
||||
import org.osmdroid.util.BoundingBox
|
||||
import org.osmdroid.util.GeoPoint
|
||||
import org.osmdroid.views.MapView
|
||||
import org.osmdroid.views.overlay.Marker
|
||||
import kotlinx.coroutines.launch
|
||||
import org.soulstone.overwatch.fusion.DetectionEvent
|
||||
import org.soulstone.overwatch.fusion.DetectionSource
|
||||
import org.soulstone.overwatch.fusion.SourceHealth
|
||||
import org.soulstone.overwatch.fusion.ThreatLevel
|
||||
import org.soulstone.overwatch.scan.DeflockClient
|
||||
import org.soulstone.overwatch.ui.theme.ThreatColors
|
||||
|
||||
@OptIn(ExperimentalMaterial3Api::class)
|
||||
@@ -75,12 +65,6 @@ fun MainScreen(
|
||||
threat: ThreatLevel,
|
||||
score: Int,
|
||||
events: List<DetectionEvent>,
|
||||
mapPoints: List<DeflockClient.AlprPoint>,
|
||||
userLocation: Location?,
|
||||
/** Visible radius of the map circle, in meters. Driven by the larger of
|
||||
* the DeFlock and Citizen proximity sliders so the user sees the full
|
||||
* area where a detection could fire. */
|
||||
mapRadiusMeters: Float,
|
||||
onStartStop: () -> Unit,
|
||||
onOpenSettings: () -> Unit,
|
||||
canStart: Boolean,
|
||||
@@ -97,26 +81,30 @@ fun MainScreen(
|
||||
.background(MaterialTheme.colorScheme.background)
|
||||
.padding(horizontal = 24.dp)
|
||||
) {
|
||||
// Box (rather than Row + SpaceBetween) so the title is truly centered
|
||||
// regardless of the gear icon's width.
|
||||
Box(
|
||||
Row(
|
||||
modifier = Modifier
|
||||
.fillMaxWidth()
|
||||
.padding(top = 8.dp)
|
||||
.padding(top = 8.dp),
|
||||
verticalAlignment = Alignment.Top,
|
||||
horizontalArrangement = Arrangement.SpaceBetween
|
||||
) {
|
||||
Text(
|
||||
text = "OVERWATCH",
|
||||
color = MaterialTheme.colorScheme.onBackground,
|
||||
fontSize = 26.sp,
|
||||
fontWeight = FontWeight.Bold,
|
||||
fontFamily = FontFamily.Monospace,
|
||||
letterSpacing = 4.sp,
|
||||
modifier = Modifier.align(Alignment.Center)
|
||||
)
|
||||
IconButton(
|
||||
onClick = onOpenSettings,
|
||||
modifier = Modifier.align(Alignment.CenterEnd)
|
||||
) {
|
||||
Column {
|
||||
Text(
|
||||
text = "[DЯΣΛMMΛKΣЯ]",
|
||||
color = MaterialTheme.colorScheme.onBackground,
|
||||
fontSize = 22.sp,
|
||||
fontWeight = FontWeight.Bold,
|
||||
fontFamily = FontFamily.Monospace
|
||||
)
|
||||
Text(
|
||||
text = " . //0VΣЯW4TCH",
|
||||
color = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||
fontSize = 18.sp,
|
||||
fontWeight = FontWeight.Medium,
|
||||
fontFamily = FontFamily.Monospace
|
||||
)
|
||||
}
|
||||
IconButton(onClick = onOpenSettings) {
|
||||
Icon(
|
||||
Icons.Filled.Settings,
|
||||
contentDescription = "Settings",
|
||||
@@ -131,15 +119,7 @@ fun MainScreen(
|
||||
modifier = Modifier.fillMaxWidth(),
|
||||
horizontalAlignment = Alignment.CenterHorizontally
|
||||
) {
|
||||
ThreatMapCircle(
|
||||
level = threat,
|
||||
animating = running,
|
||||
userLocation = userLocation,
|
||||
mapPoints = mapPoints,
|
||||
events = events,
|
||||
mapRadiusMeters = mapRadiusMeters,
|
||||
onTap = { showSheet = true }
|
||||
)
|
||||
ThreatCircle(level = threat, animating = running, onTap = { showSheet = true })
|
||||
|
||||
Spacer(Modifier.height(12.dp))
|
||||
Text(
|
||||
@@ -152,15 +132,9 @@ fun MainScreen(
|
||||
Spacer(Modifier.height(24.dp))
|
||||
|
||||
StatusText(running = running, threat = threat, score = score, events = events)
|
||||
}
|
||||
|
||||
// Push the primary action button to the bottom of the screen.
|
||||
Spacer(Modifier.weight(1f))
|
||||
Spacer(Modifier.height(24.dp))
|
||||
|
||||
Column(
|
||||
modifier = Modifier.fillMaxWidth(),
|
||||
horizontalAlignment = Alignment.CenterHorizontally
|
||||
) {
|
||||
Button(
|
||||
onClick = onStartStop,
|
||||
enabled = canStart,
|
||||
@@ -208,8 +182,6 @@ fun MainScreen(
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Spacer(Modifier.height(24.dp))
|
||||
}
|
||||
|
||||
if (showSheet) {
|
||||
@@ -235,15 +207,10 @@ fun MainScreen(
|
||||
}
|
||||
|
||||
@Composable
|
||||
private fun ThreatMapCircle(
|
||||
level: ThreatLevel,
|
||||
animating: Boolean,
|
||||
userLocation: Location?,
|
||||
mapPoints: List<DeflockClient.AlprPoint>,
|
||||
events: List<DetectionEvent>,
|
||||
mapRadiusMeters: Float,
|
||||
onTap: () -> Unit
|
||||
) {
|
||||
private fun ThreatCircle(level: ThreatLevel, animating: Boolean, onTap: () -> Unit) {
|
||||
// When the scanner isn't running, deliberately use a muted color and IDLE
|
||||
// text so the user can tell at a glance whether they're scanning. Without
|
||||
// this, idle and "scanning, all clear" both render as solid green.
|
||||
val idleColor = MaterialTheme.colorScheme.surfaceVariant
|
||||
val activeColor = when (level) {
|
||||
ThreatLevel.GREEN -> ThreatColors.Green
|
||||
@@ -251,13 +218,13 @@ private fun ThreatMapCircle(
|
||||
ThreatLevel.ORANGE -> ThreatColors.Orange
|
||||
ThreatLevel.RED -> ThreatColors.Red
|
||||
}
|
||||
// Steady threat-tier ring around the circle: tier color while scanning,
|
||||
// muted gray when idle. Gives the current level at a glance even over the map.
|
||||
val ringColor = if (animating) activeColor else idleColor
|
||||
val color = if (animating) activeColor else idleColor
|
||||
val labelText = if (animating) level.name else "IDLE"
|
||||
val labelColor = if (animating) Color.White else MaterialTheme.colorScheme.onSurfaceVariant
|
||||
|
||||
val transition = rememberInfiniteTransition(label = "pulse")
|
||||
val pulse by transition.animateFloat(
|
||||
initialValue = if (animating) 0.5f else 1.0f,
|
||||
initialValue = if (animating) 0.6f else 1.0f,
|
||||
targetValue = 1.0f,
|
||||
animationSpec = infiniteRepeatable(
|
||||
animation = tween(durationMillis = 1200),
|
||||
@@ -265,152 +232,29 @@ private fun ThreatMapCircle(
|
||||
),
|
||||
label = "pulse"
|
||||
)
|
||||
val alpha = if (animating) pulse else 1.0f
|
||||
|
||||
Box(
|
||||
modifier = Modifier
|
||||
.size(300.dp)
|
||||
.border(width = 6.dp, color = ringColor, shape = CircleShape)
|
||||
.padding(6.dp)
|
||||
.clip(CircleShape),
|
||||
.size(220.dp)
|
||||
.clip(CircleShape)
|
||||
.background(
|
||||
Brush.radialGradient(
|
||||
colors = listOf(
|
||||
color.copy(alpha = alpha),
|
||||
color.copy(alpha = alpha * 0.6f)
|
||||
)
|
||||
)
|
||||
)
|
||||
.clickable(onClick = onTap),
|
||||
contentAlignment = Alignment.Center
|
||||
) {
|
||||
// While idle OR before the first location fix arrives, fall back to the
|
||||
// solid pulsing circle — a blank/loading map mid-tile-fetch reads as
|
||||
// broken. The map only renders once we actually have something to show.
|
||||
if (!animating || userLocation == null) {
|
||||
val color = if (animating) activeColor else idleColor
|
||||
val alpha = if (animating) pulse else 1.0f
|
||||
Box(
|
||||
modifier = Modifier
|
||||
.fillMaxSize()
|
||||
.background(
|
||||
Brush.radialGradient(
|
||||
colors = listOf(
|
||||
color.copy(alpha = alpha),
|
||||
color.copy(alpha = alpha * 0.6f)
|
||||
)
|
||||
)
|
||||
),
|
||||
contentAlignment = Alignment.Center
|
||||
) {
|
||||
val labelText = when {
|
||||
!animating -> "IDLE"
|
||||
else -> "WAITING FIX"
|
||||
}
|
||||
Text(
|
||||
text = labelText,
|
||||
color = if (animating) Color.White else MaterialTheme.colorScheme.onSurfaceVariant,
|
||||
fontSize = 22.sp,
|
||||
fontWeight = FontWeight.Black,
|
||||
fontFamily = FontFamily.Monospace
|
||||
)
|
||||
}
|
||||
} else {
|
||||
// OSM map snapshot, centered on the user, with red ALPR pins and
|
||||
// a blue user-position dot. Non-interactive — touches are captured
|
||||
// by the click overlay above, so a tap opens the source-details
|
||||
// bottom sheet. Pan/zoom controls stay off.
|
||||
// Capture into a local non-null val so the AndroidView update
|
||||
// lambda doesn't run afoul of smart-cast-into-closure rules.
|
||||
val fix: Location = userLocation
|
||||
val ctx = LocalContext.current
|
||||
// Build the marker drawables once per Composition rather than
|
||||
// every recomposition — bitmap allocation isn't free.
|
||||
val userMark = remember(ctx) { crosshairDrawable(ctx.resources, 46, MARK_USER_WHITE) }
|
||||
val flockDot = remember(ctx) { dotDrawable(ctx.resources, 26, DOT_FLOCK_RED) }
|
||||
val wazeDot = remember(ctx) { dotDrawable(ctx.resources, 26, DOT_WAZE_BLUE) }
|
||||
val citizenDot = remember(ctx) { dotDrawable(ctx.resources, 26, DOT_CITIZEN_PURPLE) }
|
||||
AndroidView(
|
||||
modifier = Modifier.fillMaxSize(),
|
||||
factory = { c ->
|
||||
MapView(c).apply {
|
||||
setTileSource(TileSourceFactory.MAPNIK)
|
||||
setMultiTouchControls(false)
|
||||
setBuiltInZoomControls(false)
|
||||
isClickable = false
|
||||
isFocusable = false
|
||||
}
|
||||
},
|
||||
update = { map ->
|
||||
map.controller.setCenter(GeoPoint(fix.latitude, fix.longitude))
|
||||
map.overlays.clear()
|
||||
|
||||
// Source dots first (Flock red, Waze blue, Citizen purple),
|
||||
// user position last so the crosshair always draws on top.
|
||||
for (p in mapPoints) {
|
||||
map.overlays.add(
|
||||
Marker(map).apply {
|
||||
position = GeoPoint(p.lat, p.lon)
|
||||
setAnchor(Marker.ANCHOR_CENTER, Marker.ANCHOR_CENTER)
|
||||
icon = flockDot
|
||||
title = p.operator ?: p.manufacturer ?: "ALPR"
|
||||
setInfoWindow(null)
|
||||
}
|
||||
)
|
||||
}
|
||||
for (e in events) {
|
||||
val lat = e.lat ?: continue
|
||||
val lon = e.lon ?: continue
|
||||
val dot = when (e.source) {
|
||||
DetectionSource.WAZE -> wazeDot
|
||||
DetectionSource.CITIZEN -> citizenDot
|
||||
else -> null
|
||||
} ?: continue
|
||||
map.overlays.add(
|
||||
Marker(map).apply {
|
||||
position = GeoPoint(lat, lon)
|
||||
setAnchor(Marker.ANCHOR_CENTER, Marker.ANCHOR_CENTER)
|
||||
icon = dot
|
||||
title = e.label
|
||||
setInfoWindow(null)
|
||||
}
|
||||
)
|
||||
}
|
||||
map.overlays.add(
|
||||
Marker(map).apply {
|
||||
position = GeoPoint(fix.latitude, fix.longitude)
|
||||
setAnchor(Marker.ANCHOR_CENTER, Marker.ANCHOR_CENTER)
|
||||
icon = userMark
|
||||
setInfoWindow(null)
|
||||
}
|
||||
)
|
||||
|
||||
// Fit the visible radius to the larger of the two proximity
|
||||
// settings. Defer to map.post so the call lands after layout
|
||||
// — zoomToBoundingBox needs measured dimensions to compute
|
||||
// the right zoom level. Latitude-aware longitude scaling so
|
||||
// the bbox stays roughly square in real meters at any lat.
|
||||
val r = mapRadiusMeters.toDouble().coerceAtLeast(50.0)
|
||||
val latDegPerMeter = 1.0 / 111_000.0
|
||||
val lonDegPerMeter = 1.0 /
|
||||
(111_000.0 * cos(Math.toRadians(fix.latitude)).coerceAtLeast(0.01))
|
||||
val bbox = BoundingBox(
|
||||
fix.latitude + r * latDegPerMeter,
|
||||
fix.longitude + r * lonDegPerMeter,
|
||||
fix.latitude - r * latDegPerMeter,
|
||||
fix.longitude - r * lonDegPerMeter
|
||||
)
|
||||
map.post { map.zoomToBoundingBox(bbox, false, 0) }
|
||||
map.invalidate()
|
||||
},
|
||||
onRelease = { map -> map.onDetach() }
|
||||
)
|
||||
// Threat-tier scrim — pulses while scanning. Heavier alpha than
|
||||
// the first cut so the tier color reads at a glance over OSM
|
||||
// tiles, which are themselves cream/light by default.
|
||||
val scrimAlpha = (0.55f * pulse).coerceIn(0.40f, 0.65f)
|
||||
Box(
|
||||
modifier = Modifier
|
||||
.fillMaxSize()
|
||||
.background(activeColor.copy(alpha = scrimAlpha))
|
||||
)
|
||||
}
|
||||
// Click capture sits on top so taps reach onTap regardless of which
|
||||
// visual layer was painted underneath.
|
||||
Box(
|
||||
modifier = Modifier
|
||||
.fillMaxSize()
|
||||
.clickable(onClick = onTap)
|
||||
Text(
|
||||
text = labelText,
|
||||
color = labelColor,
|
||||
fontSize = 28.sp,
|
||||
fontWeight = FontWeight.Black,
|
||||
fontFamily = FontFamily.Monospace
|
||||
)
|
||||
}
|
||||
}
|
||||
@@ -458,14 +302,6 @@ private fun SourcesPanel(events: List<DetectionEvent>) {
|
||||
}
|
||||
}
|
||||
|
||||
/** User-facing label for a detection source. The internal enum stays MIC
|
||||
* (mic-bearing devices is the technical concept) while the UI shows the
|
||||
* friendlier "COMMERCIAL" — Nest/Ring/Echo are commercial smart-home gear. */
|
||||
private fun DetectionSource.displayLabel(): String = when (this) {
|
||||
DetectionSource.MIC -> "COMMERCIAL"
|
||||
else -> name
|
||||
}
|
||||
|
||||
@Composable
|
||||
private fun SourceRow(source: DetectionSource, events: List<DetectionEvent>) {
|
||||
val health by SourceHealth.flowFor(source).collectAsState()
|
||||
@@ -485,7 +321,7 @@ private fun SourceRow(source: DetectionSource, events: List<DetectionEvent>) {
|
||||
verticalAlignment = Alignment.CenterVertically
|
||||
) {
|
||||
Text(
|
||||
text = source.displayLabel(),
|
||||
text = source.name,
|
||||
color = MaterialTheme.colorScheme.onSurface,
|
||||
fontSize = 14.sp,
|
||||
fontWeight = FontWeight.Bold,
|
||||
@@ -554,22 +390,10 @@ private fun EventRow(e: DetectionEvent) {
|
||||
if (e.hasGeo) {
|
||||
IconButton(
|
||||
onClick = {
|
||||
// Force the pin to open in Google Maps rather than whichever
|
||||
// app holds the user's default geo: handler — Waze, etc. can
|
||||
// intercept geo: intents and we don't want that here. Falls
|
||||
// back to a generic browser intent if Maps isn't installed.
|
||||
val mapsUri = Uri.parse(
|
||||
"https://www.google.com/maps/search/?api=1&query=${e.lat},${e.lon}"
|
||||
)
|
||||
val mapsIntent = Intent(Intent.ACTION_VIEW, mapsUri)
|
||||
.setPackage("com.google.android.apps.maps")
|
||||
.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
|
||||
try {
|
||||
ctx.startActivity(mapsIntent)
|
||||
} catch (_: android.content.ActivityNotFoundException) {
|
||||
val fallback = Intent(Intent.ACTION_VIEW, mapsUri)
|
||||
.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
|
||||
try { ctx.startActivity(fallback) } catch (_: android.content.ActivityNotFoundException) {}
|
||||
val uri = Uri.parse("geo:${e.lat},${e.lon}?q=${e.lat},${e.lon}(${Uri.encode(e.label)})")
|
||||
val intent = Intent(Intent.ACTION_VIEW, uri).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
|
||||
if (intent.resolveActivity(ctx.packageManager) != null) {
|
||||
ctx.startActivity(intent)
|
||||
}
|
||||
},
|
||||
modifier = Modifier.size(28.dp)
|
||||
|
||||
@@ -1,68 +0,0 @@
|
||||
package org.soulstone.overwatch.ui
|
||||
|
||||
import android.content.res.Resources
|
||||
import android.graphics.Bitmap
|
||||
import android.graphics.Canvas
|
||||
import android.graphics.Paint
|
||||
import android.graphics.drawable.BitmapDrawable
|
||||
|
||||
/** Builds a small filled-circle Marker icon. Used for both the user-position
|
||||
* dot (blue) and the ALPR pins (red) — osmdroid's default teardrop marker
|
||||
* reads as a "click me" affordance which is wrong for a non-interactive
|
||||
* visualization, so we use simple dots instead. Shared by the in-app and
|
||||
* overlay versions of the threat circle. */
|
||||
internal fun dotDrawable(
|
||||
resources: Resources,
|
||||
sizePx: Int,
|
||||
coreColor: Int
|
||||
): BitmapDrawable {
|
||||
val bitmap = Bitmap.createBitmap(sizePx, sizePx, Bitmap.Config.ARGB_8888)
|
||||
val canvas = Canvas(bitmap)
|
||||
val outline = Paint(Paint.ANTI_ALIAS_FLAG).apply { color = 0xFFFFFFFF.toInt() }
|
||||
canvas.drawCircle(sizePx / 2f, sizePx / 2f, sizePx / 2f - 1f, outline)
|
||||
val core = Paint(Paint.ANTI_ALIAS_FLAG).apply { color = coreColor }
|
||||
canvas.drawCircle(sizePx / 2f, sizePx / 2f, sizePx / 2f - 4f, core)
|
||||
return BitmapDrawable(resources, bitmap)
|
||||
}
|
||||
|
||||
/** Builds a ⌖-style position mark (register / gun-sight): a stroked circle with
|
||||
* a cross through it, painted over a dark halo so it reads on any map tile. Used
|
||||
* for the user's own location so it stays distinct from the colored source dots. */
|
||||
internal fun crosshairDrawable(
|
||||
resources: Resources,
|
||||
sizePx: Int,
|
||||
markColor: Int
|
||||
): BitmapDrawable {
|
||||
val bitmap = Bitmap.createBitmap(sizePx, sizePx, Bitmap.Config.ARGB_8888)
|
||||
val canvas = Canvas(bitmap)
|
||||
val c = sizePx / 2f
|
||||
val r = sizePx * 0.30f
|
||||
val pad = sizePx * 0.07f
|
||||
val stroke = sizePx * 0.10f
|
||||
|
||||
val halo = Paint(Paint.ANTI_ALIAS_FLAG).apply {
|
||||
style = Paint.Style.STROKE
|
||||
color = 0xB3000000.toInt()
|
||||
strokeWidth = stroke + 3f
|
||||
strokeCap = Paint.Cap.ROUND
|
||||
}
|
||||
val mark = Paint(Paint.ANTI_ALIAS_FLAG).apply {
|
||||
style = Paint.Style.STROKE
|
||||
color = markColor
|
||||
strokeWidth = stroke
|
||||
strokeCap = Paint.Cap.ROUND
|
||||
}
|
||||
// Halo pass then color pass so the mark stays legible on light or dark tiles.
|
||||
for (p in listOf(halo, mark)) {
|
||||
canvas.drawCircle(c, c, r, p)
|
||||
canvas.drawLine(pad, c, sizePx - pad, c, p) // horizontal
|
||||
canvas.drawLine(c, pad, c, sizePx - pad, p) // vertical
|
||||
}
|
||||
return BitmapDrawable(resources, bitmap)
|
||||
}
|
||||
|
||||
// Per-source marker colors so geodata reads at a glance.
|
||||
internal const val DOT_FLOCK_RED = 0xFFD7263D.toInt() // Flock / DeFlock ALPR cameras
|
||||
internal const val DOT_WAZE_BLUE = 0xFF2196F3.toInt() // Waze police reports
|
||||
internal const val DOT_CITIZEN_PURPLE = 0xFF9C27B0.toInt() // Citizen incidents
|
||||
internal const val MARK_USER_WHITE = 0xFFFFFFFF.toInt() // the user's own position (⌖)
|
||||
@@ -1,185 +0,0 @@
|
||||
package org.soulstone.overwatch.ui
|
||||
|
||||
import androidx.compose.animation.core.RepeatMode
|
||||
import androidx.compose.animation.core.animateFloat
|
||||
import androidx.compose.animation.core.infiniteRepeatable
|
||||
import androidx.compose.animation.core.rememberInfiniteTransition
|
||||
import androidx.compose.animation.core.tween
|
||||
import androidx.compose.foundation.background
|
||||
import androidx.compose.foundation.layout.Box
|
||||
import androidx.compose.foundation.layout.fillMaxSize
|
||||
import androidx.compose.foundation.layout.size
|
||||
import androidx.compose.foundation.shape.CircleShape
|
||||
import androidx.compose.runtime.Composable
|
||||
import androidx.compose.runtime.collectAsState
|
||||
import androidx.compose.runtime.getValue
|
||||
import androidx.compose.runtime.remember
|
||||
import androidx.compose.ui.Alignment
|
||||
import androidx.compose.ui.Modifier
|
||||
import androidx.compose.ui.draw.clip
|
||||
import androidx.compose.ui.graphics.Brush
|
||||
import androidx.compose.ui.platform.LocalContext
|
||||
import androidx.compose.ui.unit.dp
|
||||
import androidx.compose.ui.viewinterop.AndroidView
|
||||
import kotlin.math.cos
|
||||
import kotlin.math.max
|
||||
import org.osmdroid.tileprovider.tilesource.TileSourceFactory
|
||||
import org.osmdroid.util.BoundingBox
|
||||
import org.osmdroid.util.GeoPoint
|
||||
import org.osmdroid.views.MapView
|
||||
import org.osmdroid.views.overlay.Marker
|
||||
import org.soulstone.overwatch.data.settings.Settings
|
||||
import org.soulstone.overwatch.fusion.DetectionSource
|
||||
import org.soulstone.overwatch.fusion.ThreatLevel
|
||||
import org.soulstone.overwatch.service.DetectionService
|
||||
import org.soulstone.overwatch.ui.theme.ThreatColors
|
||||
|
||||
/**
|
||||
* Smaller "chat-bubble" version of the threat-map circle, hosted in a
|
||||
* WindowManager overlay by [org.soulstone.overwatch.service.OverlayManager].
|
||||
*
|
||||
* Self-contained: pulls all of its data from the same companion-level
|
||||
* StateFlows the in-app [MainScreen] uses (DetectionService.running / store /
|
||||
* mapPoints / location) plus the proximity sliders from [Settings]. The
|
||||
* caller doesn't pass any state — keeps the OverlayManager dumb.
|
||||
*
|
||||
* Tap and drag are handled at the View layer (OverlayManager's OnTouchListener);
|
||||
* this composable is render-only.
|
||||
*/
|
||||
@Composable
|
||||
fun OverlayBubble() {
|
||||
val ctx = LocalContext.current
|
||||
val settings = remember(ctx) { Settings.get(ctx) }
|
||||
|
||||
val running by DetectionService.running.collectAsState()
|
||||
val threat by DetectionService.store.threatLevel.collectAsState()
|
||||
val userLocation by DetectionService.location.collectAsState()
|
||||
val mapPoints by DetectionService.mapPoints.collectAsState()
|
||||
val events by DetectionService.store.events.collectAsState()
|
||||
val deflockProx by settings.deflockProximityM.collectAsState()
|
||||
val citizenProx by settings.citizenProximityM.collectAsState()
|
||||
val wazeProx by settings.wazeProximityM.collectAsState()
|
||||
val radius = max(max(deflockProx, citizenProx), wazeProx).toFloat()
|
||||
|
||||
val activeColor = when (threat) {
|
||||
ThreatLevel.GREEN -> ThreatColors.Green
|
||||
ThreatLevel.YELLOW -> ThreatColors.Yellow
|
||||
ThreatLevel.ORANGE -> ThreatColors.Orange
|
||||
ThreatLevel.RED -> ThreatColors.Red
|
||||
}
|
||||
|
||||
val transition = rememberInfiniteTransition(label = "overlay-pulse")
|
||||
val pulse by transition.animateFloat(
|
||||
initialValue = 0.55f,
|
||||
targetValue = 1.0f,
|
||||
animationSpec = infiniteRepeatable(
|
||||
animation = tween(durationMillis = 1200),
|
||||
repeatMode = RepeatMode.Reverse
|
||||
),
|
||||
label = "overlay-pulse"
|
||||
)
|
||||
|
||||
val userMark = remember(ctx) { crosshairDrawable(ctx.resources, 34, MARK_USER_WHITE) }
|
||||
val flockDot = remember(ctx) { dotDrawable(ctx.resources, 22, DOT_FLOCK_RED) }
|
||||
val wazeDot = remember(ctx) { dotDrawable(ctx.resources, 22, DOT_WAZE_BLUE) }
|
||||
val citizenDot = remember(ctx) { dotDrawable(ctx.resources, 22, DOT_CITIZEN_PURPLE) }
|
||||
|
||||
Box(
|
||||
modifier = Modifier
|
||||
.size(140.dp)
|
||||
.clip(CircleShape),
|
||||
contentAlignment = Alignment.Center
|
||||
) {
|
||||
// The OverlayManager only attaches the bubble while running == true,
|
||||
// but check anyway — paranoia keeps the bubble from rendering a stale
|
||||
// map if a future code path lets the composition outlive the service.
|
||||
val fix = userLocation
|
||||
if (!running || fix == null) {
|
||||
Box(
|
||||
modifier = Modifier
|
||||
.fillMaxSize()
|
||||
.background(
|
||||
Brush.radialGradient(
|
||||
colors = listOf(
|
||||
activeColor.copy(alpha = pulse),
|
||||
activeColor.copy(alpha = pulse * 0.6f)
|
||||
)
|
||||
)
|
||||
)
|
||||
)
|
||||
} else {
|
||||
AndroidView(
|
||||
modifier = Modifier.fillMaxSize(),
|
||||
factory = { c ->
|
||||
MapView(c).apply {
|
||||
setTileSource(TileSourceFactory.MAPNIK)
|
||||
setMultiTouchControls(false)
|
||||
setBuiltInZoomControls(false)
|
||||
isClickable = false
|
||||
isFocusable = false
|
||||
}
|
||||
},
|
||||
update = { map ->
|
||||
map.controller.setCenter(GeoPoint(fix.latitude, fix.longitude))
|
||||
map.overlays.clear()
|
||||
for (p in mapPoints) {
|
||||
map.overlays.add(
|
||||
Marker(map).apply {
|
||||
position = GeoPoint(p.lat, p.lon)
|
||||
setAnchor(Marker.ANCHOR_CENTER, Marker.ANCHOR_CENTER)
|
||||
icon = flockDot
|
||||
title = p.operator ?: p.manufacturer ?: "ALPR"
|
||||
setInfoWindow(null)
|
||||
}
|
||||
)
|
||||
}
|
||||
for (e in events) {
|
||||
val lat = e.lat ?: continue
|
||||
val lon = e.lon ?: continue
|
||||
val dot = when (e.source) {
|
||||
DetectionSource.WAZE -> wazeDot
|
||||
DetectionSource.CITIZEN -> citizenDot
|
||||
else -> null
|
||||
} ?: continue
|
||||
map.overlays.add(
|
||||
Marker(map).apply {
|
||||
position = GeoPoint(lat, lon)
|
||||
setAnchor(Marker.ANCHOR_CENTER, Marker.ANCHOR_CENTER)
|
||||
icon = dot
|
||||
setInfoWindow(null)
|
||||
}
|
||||
)
|
||||
}
|
||||
map.overlays.add(
|
||||
Marker(map).apply {
|
||||
position = GeoPoint(fix.latitude, fix.longitude)
|
||||
setAnchor(Marker.ANCHOR_CENTER, Marker.ANCHOR_CENTER)
|
||||
icon = userMark
|
||||
setInfoWindow(null)
|
||||
}
|
||||
)
|
||||
val r = radius.toDouble().coerceAtLeast(50.0)
|
||||
val latDegPerMeter = 1.0 / 111_000.0
|
||||
val lonDegPerMeter = 1.0 /
|
||||
(111_000.0 * cos(Math.toRadians(fix.latitude)).coerceAtLeast(0.01))
|
||||
val bbox = BoundingBox(
|
||||
fix.latitude + r * latDegPerMeter,
|
||||
fix.longitude + r * lonDegPerMeter,
|
||||
fix.latitude - r * latDegPerMeter,
|
||||
fix.longitude - r * lonDegPerMeter
|
||||
)
|
||||
map.post { map.zoomToBoundingBox(bbox, false, 0) }
|
||||
map.invalidate()
|
||||
},
|
||||
onRelease = { map -> map.onDetach() }
|
||||
)
|
||||
// Tier scrim — same pulse alpha range as the in-app circle.
|
||||
val scrimAlpha = (0.55f * pulse).coerceIn(0.40f, 0.65f)
|
||||
Box(
|
||||
modifier = Modifier
|
||||
.fillMaxSize()
|
||||
.background(activeColor.copy(alpha = scrimAlpha))
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,8 +1,5 @@
|
||||
package org.soulstone.overwatch.ui
|
||||
|
||||
import android.content.Intent
|
||||
import android.net.Uri
|
||||
import android.provider.Settings as AndroidSettings
|
||||
import androidx.compose.foundation.background
|
||||
import androidx.compose.foundation.layout.Arrangement
|
||||
import androidx.compose.foundation.layout.Column
|
||||
@@ -14,11 +11,8 @@ import androidx.compose.foundation.layout.height
|
||||
import androidx.compose.foundation.layout.padding
|
||||
import androidx.compose.foundation.rememberScrollState
|
||||
import androidx.compose.foundation.verticalScroll
|
||||
import androidx.compose.ui.platform.LocalContext
|
||||
import androidx.compose.material.icons.Icons
|
||||
import androidx.compose.material.icons.automirrored.filled.ArrowBack
|
||||
import androidx.compose.material.icons.filled.Visibility
|
||||
import androidx.compose.material.icons.filled.VisibilityOff
|
||||
import androidx.compose.foundation.shape.RoundedCornerShape
|
||||
import androidx.compose.material3.Button
|
||||
import androidx.compose.material3.ButtonDefaults
|
||||
@@ -28,19 +22,14 @@ import androidx.compose.material3.IconButton
|
||||
import androidx.compose.material3.MaterialTheme
|
||||
import androidx.compose.material3.RadioButton
|
||||
import androidx.compose.material3.Slider
|
||||
import androidx.compose.material3.LocalTextStyle
|
||||
import androidx.compose.material3.OutlinedTextField
|
||||
import androidx.compose.material3.Switch
|
||||
import androidx.compose.material3.Text
|
||||
import androidx.compose.runtime.Composable
|
||||
import androidx.compose.runtime.collectAsState
|
||||
import androidx.compose.runtime.getValue
|
||||
import androidx.compose.runtime.mutableFloatStateOf
|
||||
import androidx.compose.runtime.mutableStateOf
|
||||
import androidx.compose.runtime.remember
|
||||
import androidx.compose.runtime.setValue
|
||||
import androidx.compose.ui.text.input.PasswordVisualTransformation
|
||||
import androidx.compose.ui.text.input.VisualTransformation
|
||||
import androidx.compose.ui.Alignment
|
||||
import androidx.compose.ui.Modifier
|
||||
import androidx.compose.ui.text.font.FontFamily
|
||||
@@ -60,16 +49,10 @@ fun SettingsScreen(
|
||||
val wifi by settings.wifiEnabled.collectAsState()
|
||||
val deflock by settings.deflockEnabled.collectAsState()
|
||||
val citizen by settings.citizenEnabled.collectAsState()
|
||||
val waze by settings.wazeEnabled.collectAsState()
|
||||
val mic by settings.micEnabled.collectAsState()
|
||||
val deflockProx by settings.deflockProximityM.collectAsState()
|
||||
val citizenProx by settings.citizenProximityM.collectAsState()
|
||||
val wazeProx by settings.wazeProximityM.collectAsState()
|
||||
val wazeToken by settings.wazeProxyToken.collectAsState()
|
||||
val theme by settings.themeMode.collectAsState()
|
||||
val vibrate by settings.vibrateOnAlert.collectAsState()
|
||||
val overlay by settings.overlayEnabled.collectAsState()
|
||||
val context = LocalContext.current
|
||||
|
||||
Column(
|
||||
modifier = Modifier
|
||||
@@ -99,8 +82,6 @@ fun SettingsScreen(
|
||||
SourceToggle("WIFI • WiFi BSSID + SSID", wifi) { settings.setWifiEnabled(it) }
|
||||
SourceToggle("DEFLOCK • ALPR map (Overpass)", deflock) { settings.setDeflockEnabled(it) }
|
||||
SourceToggle("CITIZEN • Real-time incident feed", citizen) { settings.setCitizenEnabled(it) }
|
||||
SourceToggle("WAZE • Live police reports", waze) { settings.setWazeEnabled(it) }
|
||||
SourceToggle("COMMERCIAL • Nest, Ring, Echo", mic) { settings.setMicEnabled(it) }
|
||||
Spacer(Modifier.height(8.dp))
|
||||
if (isRunning) {
|
||||
Button(
|
||||
@@ -142,55 +123,11 @@ fun SettingsScreen(
|
||||
steps = 48,
|
||||
onCommit = { settings.setCitizenProximityM(it) }
|
||||
)
|
||||
SliderRow(
|
||||
label = "Waze alert distance",
|
||||
persistedValue = wazeProx,
|
||||
range = 100f..5000f,
|
||||
steps = 48,
|
||||
onCommit = { settings.setWazeProximityM(it) }
|
||||
)
|
||||
|
||||
Spacer(Modifier.height(16.dp))
|
||||
SectionLabel("Waze police feed")
|
||||
Text(
|
||||
"Needs a proxy token (api.blackflagintel.com). Stored encrypted on-device — never in the app package.",
|
||||
fontSize = 11.sp,
|
||||
color = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||
fontFamily = FontFamily.Monospace,
|
||||
modifier = Modifier.padding(vertical = 4.dp)
|
||||
)
|
||||
TokenField(currentToken = wazeToken, onSave = { settings.setWazeProxyToken(it) })
|
||||
|
||||
Spacer(Modifier.height(16.dp))
|
||||
SectionLabel("Alerts")
|
||||
SourceToggle("Vibrate on threat escalation", vibrate) { settings.setVibrateOnAlert(it) }
|
||||
|
||||
Spacer(Modifier.height(16.dp))
|
||||
SectionLabel("Display over other apps")
|
||||
SourceToggle("Floating threat circle", overlay) { enabled ->
|
||||
settings.setOverlayEnabled(enabled)
|
||||
// Special-access perm: can't be granted via runtime prompt. Bounce
|
||||
// the user to the system settings page for this app so they can
|
||||
// approve. The DetectionService re-checks canDrawOverlays at show()
|
||||
// time so a denied/revoked perm just means the bubble silently
|
||||
// doesn't appear — no crash.
|
||||
if (enabled && !AndroidSettings.canDrawOverlays(context)) {
|
||||
val intent = Intent(
|
||||
AndroidSettings.ACTION_MANAGE_OVERLAY_PERMISSION,
|
||||
Uri.parse("package:${context.packageName}")
|
||||
).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
|
||||
try { context.startActivity(intent) } catch (_: Exception) {}
|
||||
}
|
||||
}
|
||||
if (overlay && !AndroidSettings.canDrawOverlays(context)) {
|
||||
Text(
|
||||
"Permission needed — system page should have opened. If not, grant manually under Apps → OVERWATCH → Display over other apps.",
|
||||
fontSize = 11.sp,
|
||||
color = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||
modifier = Modifier.padding(vertical = 4.dp)
|
||||
)
|
||||
}
|
||||
|
||||
Spacer(Modifier.height(16.dp))
|
||||
SectionLabel("Appearance")
|
||||
ThemeRadio("System default", theme == Settings.ThemeMode.SYSTEM) {
|
||||
@@ -228,16 +165,11 @@ private fun SourceToggle(label: String, value: Boolean, onChange: (Boolean) -> U
|
||||
verticalAlignment = Alignment.CenterVertically,
|
||||
horizontalArrangement = Arrangement.SpaceBetween
|
||||
) {
|
||||
// weight(1f) reserves the remaining row width for the label so it
|
||||
// wraps on narrow screens instead of clipping under the Switch.
|
||||
Text(
|
||||
text = label,
|
||||
color = MaterialTheme.colorScheme.onBackground,
|
||||
fontSize = 14.sp,
|
||||
fontFamily = FontFamily.Monospace,
|
||||
modifier = Modifier
|
||||
.weight(1f, fill = true)
|
||||
.padding(end = 12.dp)
|
||||
fontFamily = FontFamily.Monospace
|
||||
)
|
||||
Switch(checked = value, onCheckedChange = onChange)
|
||||
}
|
||||
@@ -285,63 +217,6 @@ private fun SliderRow(
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Masked entry for the Waze proxy token. Commits on Save (persisted encrypted
|
||||
* via Settings/SecureStore), with a show/hide toggle and a set/unset status line.
|
||||
*/
|
||||
@Composable
|
||||
private fun TokenField(currentToken: String, onSave: (String) -> Unit) {
|
||||
var text by remember(currentToken) { mutableStateOf(currentToken) }
|
||||
var visible by remember { mutableStateOf(false) }
|
||||
val isSet = currentToken.isNotBlank()
|
||||
Column(modifier = Modifier.padding(vertical = 4.dp)) {
|
||||
OutlinedTextField(
|
||||
value = text,
|
||||
onValueChange = { text = it },
|
||||
singleLine = true,
|
||||
label = { Text("Proxy token", fontFamily = FontFamily.Monospace, fontSize = 12.sp) },
|
||||
visualTransformation =
|
||||
if (visible) VisualTransformation.None else PasswordVisualTransformation(),
|
||||
trailingIcon = {
|
||||
IconButton(onClick = { visible = !visible }) {
|
||||
Icon(
|
||||
if (visible) Icons.Filled.VisibilityOff else Icons.Filled.Visibility,
|
||||
contentDescription = if (visible) "Hide token" else "Show token"
|
||||
)
|
||||
}
|
||||
},
|
||||
textStyle = LocalTextStyle.current.copy(
|
||||
fontFamily = FontFamily.Monospace, fontSize = 13.sp
|
||||
),
|
||||
modifier = Modifier.fillMaxWidth()
|
||||
)
|
||||
Spacer(Modifier.height(6.dp))
|
||||
Row(
|
||||
modifier = Modifier.fillMaxWidth(),
|
||||
horizontalArrangement = Arrangement.SpaceBetween,
|
||||
verticalAlignment = Alignment.CenterVertically
|
||||
) {
|
||||
Text(
|
||||
text = if (isSet) "Token set — Waze feed enabled" else "No token — Waze feed off",
|
||||
color = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||
fontSize = 11.sp,
|
||||
fontFamily = FontFamily.Monospace,
|
||||
modifier = Modifier.weight(1f, fill = true)
|
||||
)
|
||||
Button(
|
||||
onClick = { onSave(text) },
|
||||
colors = ButtonDefaults.buttonColors(
|
||||
containerColor = MaterialTheme.colorScheme.surfaceVariant,
|
||||
contentColor = MaterialTheme.colorScheme.onSurface
|
||||
),
|
||||
shape = RoundedCornerShape(8.dp)
|
||||
) {
|
||||
Text("Save", fontSize = 13.sp, fontFamily = FontFamily.Monospace)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Composable
|
||||
private fun ThemeRadio(label: String, selected: Boolean, onClick: () -> Unit) {
|
||||
Row(
|
||||
|
||||
@@ -1,12 +1,14 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<resources>
|
||||
<string name="app_name">OVERWATCH</string>
|
||||
<string name="app_name">[DЯΣΛMMΛKΣЯ] OVERWATCH</string>
|
||||
<string name="title_line1">[DЯΣΛMMΛKΣЯ]</string>
|
||||
<string name="title_line2"> . //0VΣЯW4TCH</string>
|
||||
<string name="status_idle">Idle — press START to begin scanning</string>
|
||||
<string name="status_scanning_clear">All clear</string>
|
||||
<string name="status_scanning">Scanning…</string>
|
||||
<string name="action_start">START</string>
|
||||
<string name="action_stop">STOP</string>
|
||||
<string name="notification_channel_name">OVERWATCH detection</string>
|
||||
<string name="notification_channel_name">DREAMMAKER / OVERWATCH detection</string>
|
||||
<string name="notification_channel_desc">Foreground notification while scanning</string>
|
||||
<string name="notification_title">OVERWATCH active</string>
|
||||
<string name="notification_text">Scanning for nearby surveillance</string>
|
||||
|
||||
@@ -7,7 +7,6 @@ activityCompose = "1.9.3"
|
||||
composeBom = "2024.12.01"
|
||||
material3 = "1.3.1"
|
||||
playServicesLocation = "21.3.0"
|
||||
osmdroid = "6.1.20"
|
||||
|
||||
[libraries]
|
||||
androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
|
||||
@@ -22,7 +21,6 @@ androidx-compose-ui-tooling = { group = "androidx.compose.ui", name = "ui-toolin
|
||||
androidx-compose-material3 = { group = "androidx.compose.material3", name = "material3" }
|
||||
androidx-compose-material-icons-extended = { group = "androidx.compose.material", name = "material-icons-extended" }
|
||||
play-services-location = { group = "com.google.android.gms", name = "play-services-location", version.ref = "playServicesLocation" }
|
||||
osmdroid-android = { group = "org.osmdroid", name = "osmdroid-android", version.ref = "osmdroid" }
|
||||
|
||||
[plugins]
|
||||
android-application = { id = "com.android.application", version.ref = "agp" }
|
||||
|
||||
@@ -14,8 +14,3 @@ sdk.dir=/Users/YOUR_USERNAME/Library/Android/sdk
|
||||
# in your shell profile
|
||||
# (b) put the line below into ~/.gradle/gradle.properties (NOT project gradle.properties):
|
||||
# org.gradle.java.home=/usr/local/opt/openjdk@21/libexec/openjdk.jdk/Contents/Home
|
||||
|
||||
# The Waze police source no longer uses an app-side key. The OpenWeb Ninja key
|
||||
# lives only on the api.blackflagintel.com proxy (server-side); the app calls
|
||||
# that proxy with a token pasted into Settings (stored encrypted on-device).
|
||||
# Nothing to configure here for Waze.
|
||||
|
||||
Reference in New Issue
Block a user