Location,
Integrity &
Presence

GNSS

lat/lon · accuracy · age

Wi-Fi

top BSSID · RSSI

BLE

emisores fijos · RSSI

Cell

serving · vecinas

SmileyCapabilities.kt

Kotlin · tablet

data class SmileyCapabilities(

val sdk: Int, val sensors: List<String>, val gyro: Boolean,

val bleAdvertiser: Boolean, val wifiRtt: Boolean, val gnss: Boolean,

)

 

fun probe(ctx: Context): SmileyCapabilities {

val sm = ctx.getSystemService(SensorManager::class.java)

val bt = ctx.getSystemService(BluetoothManager::class.java).adapter

val pm = ctx.packageManager

return SmileyCapabilities(

sdk = Build.VERSION.SDK_INT,

sensors = sm.getSensorList(Sensor.TYPE_ALL).map { it.name },

gyro = sm.getDefaultSensor(Sensor.TYPE_GYROSCOPE) != null,

bleAdvertiser = bt.isMultipleAdvertisementSupported,

wifiRtt = pm.hasSystemFeature(PackageManager.FEATURE_WIFI_RTT),

gnss = pm.hasSystemFeature(PackageManager.FEATURE_LOCATION_GPS),

)

}

Nada se asume

Giroscopio, RTT y advertiser se le preguntan al hardware real.

Viaja al backend

El resultado sale con el primer heartbeat y queda como ficha del equipo.

Primera entrega

Una pantalla de diagnóstico, antes que cualquier lógica de inferencia.

Enrollment.kt

Kotlin · tablet

data class ApStat(val medianRssi: Int, val seenRatio: Double)

 

data class LocationProfile(

val zone: String, // "AEP/T1/ARR/CINTA_04"

val aps: Map<String, ApStat>, // BSSID -> estadísticos

val gravity: FloatArray, // orientación instalada

)

 

suspend fun enroll(zone: String, s: Sensors): LocationProfile {

val scans = List(8) { s.wifi().also { delay(30_000) } }

val aps = scans.flatMap { it.keys }.distinct().associateWith { id ->

val seen = scans.mapNotNull { it[id] }.sorted()

ApStat(seen[seen.size / 2], seen.size / scans.size.toDouble())

}

return LocationProfile(zone, aps, s.gravity())

}

Estadísticos, no una lectura

Mediana de RSSI y frecuencia de aparición por BSSID.

El throttle manda

Android permite 4 scans cada 2 minutos. Ocho muestras llevan 4 minutos.

Gravedad incluida

El vector del equipo ya amurado es la referencia para tilt.

WifiFingerprint.kt

Kotlin · tablet

@SuppressLint("MissingPermission")

suspend fun WifiManager.scanOnce(ctx: Context): Map<String, Int> =

suspendCancellableCoroutine { cont ->

fun snapshot() = scanResults.associate { it.BSSID to it.level }

val rx = object : BroadcastReceiver() {

override fun onReceive(c: Context, i: Intent) {

ctx.unregisterReceiver(this)

cont.resume(snapshot())

}

}

val action = WifiManager.SCAN_RESULTS_AVAILABLE_ACTION

ctx.registerReceiver(rx, IntentFilter(action))

cont.invokeOnCancellation { ctx.unregisterReceiver(rx) }

if (!startScan()) { // throttled: uso el último resultado

ctx.unregisterReceiver(rx)

cont.resume(snapshot())

}

}

Sin asociarse

El scan devuelve BSSID y RSSI de todo lo visible, aunque la tablet use 4G.

4 scans cada 2 min

En foreground alcanza para el baseline horario y el burst por movimiento.

Location encendida

Sin el permiso de ubicación y el servicio activo, la lista viene vacía.

Similarity.kt

Kotlin · tablet o backend

/** 0.0 = otro lugar · 1.0 = idéntico al baseline */

fun similarity(

base: Map<String, ApStat>,

now: Map<String, Int>,

): Double {

val stable = base.filterValues { it.seenRatio >= 0.8 }

if (stable.isEmpty()) return 0.0

val score = stable.entries.sumOf { (bssid, stat) ->

val rssi = now[bssid] ?: return@sumOf 0.0

val delta = abs(rssi - stat.medianRssi)

(1.0 - delta / 30.0).coerceIn(0.0, 1.0)

}

return score / stable.size

}

Sólo APs estables

Los que aparecen en menos del 80% de las muestras no cuentan.

IntegrityDetector.kt

Kotlin · tablet

class IntegrityDetector(

private val cfg: Thresholds, // remotos, por gabinete

private val baseG: FloatArray, // gravedad del enrollment

private val emit: (IntegrityEvent) -> Unit,

) : SensorEventListener {

private val g = baseG.copyOf()

override fun onSensorChanged(e: SensorEvent) {

for (i in 0..2) g[i] = 0.9f * g[i] + 0.1f * e.values[i]

val lin = FloatArray(3) { e.values[it] - g[it] }.norm()

val tilt = angleDeg(g, baseG)

when {

lin > cfg.impactMs2 -> emit(Impact(peak = lin))

lin > cfg.moveMs2 -> emit(Movement(energy = lin))

tilt > cfg.tiltDeg -> emit(Tilt(deg = tilt))

}

}

override fun onAccuracyChanged(s: Sensor, accuracy: Int) = Unit

}

Gravedad por low-pass

Al restarla queda la aceleración lineal. No hace falta giroscopio.

Tilt contra el enrollment

Equipo amurado, vector constante. Un desvío sostenido es la mejor señal de retiro.

Thresholds remotos

No existe "2 g = golpe". Se calibran sobre el gabinete real y llegan del backend.

HitClassifier.kt

Kotlin · tablet

enum class Hit { STRONG_TAP, PALM, FRONT_OBJECT, SIDE }

class HitClassifier(private val cfg: Thresholds) {

private var lastDown = 0L to 0f // uptimeMillis, touchMajor

fun onTouch(e: MotionEvent) {

if (e.actionMasked != MotionEvent.ACTION_DOWN) return

lastDown = e.eventTime to e.touchMajor

}

fun onImpact(lin: FloatArray, atMs: Long): Hit {

val touched = abs(atMs - lastDown.first) < 150

val frontal = abs(lin[2]) > maxOf(abs(lin[0]), abs(lin[1]))

return when {

touched && lastDown.second > cfg.palmPx -> Hit.PALM

touched -> Hit.STRONG_TAP

frontal -> Hit.FRONT_OBJECT

else -> Hit.SIDE

}

}

}

Un solo reloj

El touch trae uptimeMillis. El impacto se sella con el mismo reloj al recibirlo.

Eje Z = frontal

Si pegan en el vidrio, domina el impulso perpendicular a la pantalla.

Votos bajo sospecha

Tras PALM o FRONT_OBJECT, los votos de los segundos siguientes van marcados.

BurstTrigger.kt

Kotlin · tablet

class BurstTrigger(

private val scope: CoroutineScope, private val s: Sensors,

private val queue: EventQueue,

) {

private var last = 0L

fun onIntegrity(ev: IntegrityEvent) {

queue.put(ev)

val now = SystemClock.elapsedRealtime()

if (now - last < 30_000) return // debounce

last = now

scope.launch {

val gnss = async { s.location() }

val wifi = async { s.wifi() }

val ble = s.ble(windowMs = 4_000)

queue.put(Burst(ev.id, gnss.await(), wifi.await(), ble))

}

}

}

14:31:02

IMPACT pico corto

14:31:05

MOVEMENT sostenido

14:31:06

BURST GNSS, Wi-Fi, BLE

14:31:18

similarity 0.21 sale del baseline

14:31:44

GNSS fix mejora la accuracy

14:32:10

REMOVAL lo concluye el backend

EventQueue.kt

Kotlin · Room

@Entity(tableName = "events")

data class EventRow(

@PrimaryKey(autoGenerate = true) val seq: Long = 0,

val type: String,

val ts: Long,

val payload: String, // JSON

val sent: Boolean = false,

)

 

@Dao

interface EventDao {

@Insert suspend fun put(e: EventRow): Long

@Query("SELECT * FROM events WHERE sent = 0 ORDER BY seq LIMIT :n")

suspend fun pending(n: Int = 50): List<EventRow>

@Query("UPDATE events SET sent = 1 WHERE seq <= :upTo")

suspend fun ack(upTo: Long)

}

seq monotónico

El backend detecta huecos y descarta duplicados.

ack por rango

El POST devuelve el último seq persistido y la tablet marca hasta ahí.

Crudo primero

Mientras se calibra, el payload lleva las muestras crudas. El volumen es chico.

ProximityMonitor.kt

Kotlin · tablet

data class BleContext(val seen: Int, val near: Int, val strongest: Int?)

 

class ProximityMonitor(private val nearDbm: Int = -55) {

private val seen = ConcurrentHashMap<String, Pair<Int, Long>>()

private fun now() = SystemClock.elapsedRealtime()

val callback = object : ScanCallback() {

override fun onScanResult(type: Int, r: ScanResult) {

seen[r.device.address] = r.rssi to now()

}

}

 

// Sólo RAM: las direcciones nunca van a disco ni al backend

fun snapshot(windowMs: Long = 10_000): BleContext {

seen.values.removeIf { it.second < now() - windowMs }

val v = seen.values.map { it.first }

return BleContext(v.size, v.count { it > nearDbm }, v.maxOrNull())

}

}

-55 dBm para empezar

Ronda el metro. Se ajusta por gabinete y viaja como config remota.

Pantalla prendida

Android pausa los scans sin filtro con la pantalla apagada. En kiosco no pasa.

Reiniciar el scan

Uno muy largo se degrada a oportunista. Reiniciarlo cada 20 minutos y validarlo en el probe.

PresenceSensor.kt

Kotlin · tablet

@SuppressLint("MissingPermission")

class PresenceSensor(private val scanner: BluetoothLeScanner) {

private val monitor = ProximityMonitor()

private val settings = ScanSettings.Builder()

.setScanMode(ScanSettings.SCAN_MODE_LOW_POWER)

.build()

 

fun start() = scanner.startScan(null, settings, monitor.callback)

fun stop() = scanner.stopScan(monitor.callback)

 

/** Ventana corta alrededor del voto */

fun onVote(vote: Vote): VoteEvent =

VoteEvent(vote, ble = monitor.snapshot(windowMs = 10_000))

 

/** ¿Hay alguien enfrente? Attract mode y tasa de respuesta */

fun someoneNear(): Boolean = monitor.snapshot(3_000).near > 0

}

Sale sólo el agregado

seen, near y strongest. Ni direcciones ni un hash por voto.

Tasa de respuesta

Cada minuto sale un PRESENCE con el pico de near. El backend divide votos por presencias.

Votos repetidos

Se compara en RAM contra el voto anterior y sale un booleano. La dirección no se guarda.

SmileyBeacon.kt

Kotlin · tablet

val WD_UUID: ParcelUuid =

ParcelUuid.fromString("7d2f0a41-5c1e-4b8a-9a6f-3e1c9b2d4f10")

@SuppressLint("MissingPermission")

fun BluetoothAdapter.announce(rotatingId: ByteArray): Boolean {

if (!isMultipleAdvertisementSupported) return false

val settings = AdvertiseSettings.Builder()

.setAdvertiseMode(AdvertiseSettings.ADVERTISE_MODE_LOW_POWER)

.setTxPowerLevel(AdvertiseSettings.ADVERTISE_TX_POWER_LOW)

.setConnectable(false)

.build()

val data = AdvertiseData.Builder()

.setIncludeDeviceName(false)

.addServiceData(WD_UUID, rotatingId) // 6 bytes, sin PII

.build()

val cb = object : AdvertiseCallback() {}

bluetoothLeAdvertiser.startAdvertising(settings, data, cb)

return true

}

ID rotativo

HMAC de la clave del equipo y la ventana de 15 minutos, truncado a 6 bytes.

Uso más cercano

La app WorkDone lo escucha y prueba que el operario estuvo ahí, junto al NFC.

Apagable por sitio

Es config remota. Nunca intenta provocar pop-ups en teléfonos ajenos.

Corte de energía

La señal de retiro más barata. Sale al instante, sin esperar el batch.

Dead-man's switch

Quien se lleva el equipo lo apaga. Un equipo apagado no avisa nada.

Heartbeat cada 5 min

Tres perdidos seguidos y el backend levanta DEVICE_SILENT.

POST /events

JSON

{

"deviceId": "WD-AEP-042",

"seq": 18233,

"event": "POSITION",

"ts": "2026-10-04T21:15:20-03:00",

"cause": "PERIODIC",

"location": {

"profile": "AEP/T1/ARR/CINTA_04",

"similarity": 0.94,

"gnssAccuracyM": 63.0

},

"radio": { "wifi": "wf_91ab", "ble": "bf_7c2e" },

"presence": { "seen": 7, "near": 1, "strongest": -37 },

"power": { "onBattery": false, "level": 100 }

}

Los manda la tablet

Los concluye el backend

Classifier.kt

Kotlin · backend

enum class Verdict {

QUIET, IMPACT, MANIPULATED, RELOCATION, REMOVAL, DEVICE_SILENT

}

 

data class Window(

val moved: Boolean, val tilted: Boolean, val impact: Boolean,

val similarity: Double, val gnssOutdoor: Boolean,

val silentFor: Duration,

)

 

fun classify(w: Window): Verdict = when {

w.silentFor > 15.minutes -> Verdict.DEVICE_SILENT

w.moved && w.similarity < 0.35 && w.gnssOutdoor -> Verdict.REMOVAL

w.moved && w.similarity < 0.35 -> Verdict.RELOCATION

w.moved || w.tilted -> Verdict.MANIPULATED

w.impact -> Verdict.IMPACT

else -> Verdict.QUIET

}

impacto solo

IMPACT

movimiento, misma radio

MANIPULATED

movimiento + cambio de radio

RELOCATION

lo anterior + GNSS outdoor

REMOVAL

sin heartbeat

DEVICE_SILENT

4 scans cada 2 min

Throttle de Wi-Fi en foreground. En background es 1 cada 30 minutos entre todas las apps.

Kiosco = foreground

Pantalla prendida y alimentación fija esquivan casi todas las restricciones de background.

Device Owner

Lock task y permisos por policy. Ubicación tiene reglas propias desde Android 12: validarlo en el probe.

SmileyCapabilities

SmileyDiagnostics

SensorTelemetry

WifiFingerprint

BleFingerprint

LocationSnapshot

MovementEvent

ImpactEvent

1

Probe y pantalla de diagnóstico en la A11 real.

2

Telemetría cruda subiendo por 4G con cola offline.

3

Experimento de estabilidad corriendo 72 horas.

4

Recién ahí, thresholds e inferencia.