stopdash

StopDash — privacy

This describes what stopdash keeps, what leaves the device, and — in detail — what its on-device diagnostic log carries. It is the disclosure AGENTS.md requires to exist before any on-device logging ships. The full store-facing Play Data Safety statement is finalized at release (see TODO.md Phase 5); this document is the engineering-level truth those answers are built from.

What leaves the device

StopDash is a client-only app. Its network calls go to: Transport for London’s Unified API, the calls that are the product; — on a release build only — Google Play, to ask whether an app update is available (detailed below; it carries nothing about you); and National Rail’s live departure boards (the Rail Data Marketplace), with a National Rail key of your own, or without one through stopdash’s own proxy (both detailed below). Google is asked only when you share a Google Maps short link into the app, to learn the place it points to (see Find a station). stopdash’s own proxy is asked for National Rail’s disruption notices, a request that carries nothing about you (see National Rail disruption notices). Firebase is added only if you turn on Help make StopDash better (off by default; see Crash reports and usage stats below). Your location, the stops and lines you look up, and your API keys go only to TfL, or with National Rail times also to National Rail, directly or through the proxy (if you opt in, Firebase sees only the rough region Google infers from your IP address), and only ever what a request needs to answer your question about departures: the details of what you’re looking up (your location for “near me now” and for a trip you plan from it — precise if you grant precise and a precise fix is available, otherwise approximate (if you grant only approximate, or if no precise fix can be obtained) — or the stop or line you’re after) and, if you’ve set an optional TfL API key (app_key), that key as your own credential, sent with your own TfL calls and nowhere else. Location is sent only on demand, never in the background: when you open the near-me list, refresh it, or come back to the app, and while the list is on screen, when you’ve walked 100 m or more since it was found (at most once a minute), so it follows you. In and around London, the stops near you are found on the phone instead, from a list of TfL’s stops built into the app, so finding them sends your location nowhere; TfL is asked for them, with your location, only when you’re near or past the edge of that area, and only by the app, never the widget (below). The one use beyond that is a trip you start: it’s checked on the phone while you walk to a stop you’re boarding at, while you wait there, just after you board, and as your train nears the station you get off at, app open or closed, and never sent (see On the way, below).

National Rail times. With a National Rail API key of your own (from the Rail Data Marketplace, pasted in Settings), or through stopdash’s own proxy without one (below), stopdash also asks National Rail’s live departure boards for the departures at a railway station you’re looking at. That request carries only the station’s three-letter National Rail code (e.g. WAT for Waterloo) and your key, never your location. A trip with a National Rail ride, planned or on the way, also asks the board where the ride boards for its trains that call where you get off, so it can tell one that stops there from one that doesn’t: that request carries the station you get off at’s code too. While a trip on the way has a National Rail ride, it also asks, about every 30 seconds, for the boards at stations on your train’s way from where you board, some listing only trains to one terminus: those stations’ codes and the termini of trains there, which their departures already show, with your key (see A trip on the way). Those stations are where you board, while it works out which train is yours (toward the trains there it checks); the one just ahead of you, once you’re on board but your train isn’t known yet (its departures, and toward the trains there it checks), up to three trains checked in all each refresh, one board each; and, while it follows your train, the station it’s due at next, the one after it and one it may be held at, at most three a refresh. For a train more than about 25 minutes away from where you board, the board there is asked from a later time, in quarter hours, which says roughly when your train is due. Usually that’s one or two boards a refresh. A National Rail train’s route page asks the station’s board toward where the train ends for the stops it makes: the station’s code and the code of the station the train ends at, which its departure already shows. A National Rail line’s timetable, opened from its route page, asks the station’s board for the next four hours in two requests, again every two minutes while it stays open: the station’s code and, for one of the line’s ways, the code of the station its trains end at, or for a favorite ride the station you get off at. Your key is your own credential, sent only with those requests, never logged. Without a key of your own, the same requests go to stopdash’s own proxy instead, which asks National Rail with stopdash’s key: it sees the same station codes and your connection’s IP address, passes on only the codes, and logs nothing. To protect National Rail’s limits it counts, for one minute, the requests it couldn’t answer from its cache, under a key your IP address can’t be recovered from, and keeps nothing else about you. The station codes themselves come bundled with the app, built from NaPTAN, the Department for Transport’s public stop list.

National Rail disruption notices. Where TfL’s status for a National Rail line is only a link to National Rail’s disruption page, stopdash asks its own small proxy for National Rail’s current notices, to show their words instead. That request carries nothing about you: no location, station, line or key. Like any server, the proxy sees your connection’s IP address. It keeps no log of requests and no record of who asked, and passes nothing about you on to National Rail. Cloudflare, which hosts the proxy, keeps its own sampled records of requests to it, which can include your IP address, for about a month, as any web host does.

Nothing else leaves the device to stopdash unless you turn on Help make StopDash better in Settings, which is off by default (see Crash reports and usage stats below): no third-party tracker, no ads, and no server of stopdash’s own beyond that proxy, which keeps nothing about you beyond the one-minute count of National Rail board requests described above (its host’s sampled request records aside).

On a release build, stopdash makes one other kind of network call — to Google Play, asking whether an app update is available (this drives the “update available” dot on the menu). It is a Play Services query about the app’s own version; it sends no location, watched stops, API key, or any other user data — nothing about you or your travel — so it adds no new Play Data Safety category beyond Google Play’s existing role as the app’s distributor. It is free, runs release-only (a debug build isn’t a Play app), and silently does nothing if Play is unavailable.

Three channels other than a TfL or National Rail request can carry user data off the device, and all three are under your control rather than stopdash’s. The first is the crash reports and usage stats you can opt in to (see below): off unless you turn them on, they send Firebase crash details, app interactions, device details and identifiers, and the approximate region Google derives from your IP address, but never your location, stops or journeys. The second is your own Android backup and device-to-device transfer, if you have it enabled: like any app’s data, your saved stopdash data (your settings and its last-good departures snapshot, which lists the widget’s nearby stops nearest first, and which of them the app shows each line from, and the widget’s favorite rides nearest first, named by their ends, but never how far each was) rides it, so a phone swap keeps your setup — all but the crash-report opt-in, which stays with the install, the rows your watch’s complications show, which the phone relearns from the watch, and the stops the app last found near you, which say where you are now and are kept on the phone only. That is Android’s channel, tied to your Google account — not something stopdash sends. The third is a bug report you choose to send (see Sending a bug report below): it hands the app you pick a diagnostic report that, unlike everything else here, includes your exact location and a screenshot of the screen you sent it from — but only after a consent screen that says so, and then to your clipboard and the app you pick (the clipboard copy happens as soon as you confirm — detailed below). So the guarantee is precise rather than absolute: without your opt-in, the only user data stopdash itself sends off the device goes in its TfL requests, and its National Rail requests, to National Rail with a key of your own or otherwise through stopdash’s proxy (the Play update check carries none), plus, if a paired watch has the StopDash watch app, the widget’s stops and departures, and any trip on the way, to that watch (above); with it, the crash reports and usage stats above go to Firebase too. Android’s backup carries your saved data under your control, and a bug report carries what you consent to share.

Your Wear OS watch (optional). If a watch paired with your phone has the StopDash watch app installed, the phone sends it what your home-screen widget shows, so the watch can show it too: the widget’s stops (their names and IDs, and the nearby stops each is compared against, which are worked out from your phone’s last location), the order they sit nearest you and which of them the app shows each line from, never how far each is, so the watch shows each line once, from the same stop as the app, their departures, TfL’s public service status for their lines (such as “Severe Delays”) and the work TfL has announced on them for a later day (such as a weekend closure), for each direction where TfL says an alert only affects one way, whether you dismissed it in the app, and which of those stops a bus alert is wholly behind (worked out on the phone from TfL’s routes), which rows you’ve starred, and which kinds of transport you’ve hidden, plus TfL’s current routes for a branching line where they differ from the ones built into the app (public data, the same for everyone). It never sends your coordinates or your API keys, and the watch never contacts TfL, National Rail or anything else itself. In the other direction, the watch sends the phone its requests to refresh, which carry only a random request number, and the row each StopDash complication shows (its stop ID, line and direction), so the phone keeps those rows in what it sends. This goes through Google Play services’ Wearable Data Layer: over Bluetooth when the watch is near, but when it isn’t (a watch on Wi-Fi or mobile data) it may pass through Google’s servers. Nothing is sent when no paired watch has the app. The watch keeps only the latest copy, never backs it up, and doesn’t log it. While the phone follows a trip on the way, it also sends the watch that trip, so the watch can show where you are in it: its steps (each walk and ride, the line, and the stations at each end, so where you’re going), the step you’re at with what to do there now, and the trains for your next ride. It goes the same way as above, and the phone takes it off the Data Layer when the trip ends. If the phone app stops without ending the trip, the watch stops showing it after 15 minutes, but the Data Layer keeps that last copy until the phone next sends or removes a trip. The watch app itself holds it in memory only. For Play’s Data Safety form, the determination is that this moves your own data between your own devices and stopdash never receives it, so it adds no data type collected by the developer. Google’s Data Layer documentation says what passes through its servers is end-to-end encrypted between your phone and your watch, and between them over Bluetooth the link is encrypted too.

Find a station (the menu’s From… and To…, a station’s To…, and a trip’s Via…) looks up what you type in lists of London’s stations and bus stops that ship inside the app, on your device; in From… and To… also in a list of London places, streets and postcodes that ships inside the app. What you type isn’t sent anywhere, with two exceptions for places outside London, which those lists don’t cover: if you tap Search outside London, or type a complete postcode the list doesn’t hold, the text you typed (and nothing else) is sent to TfL’s Journey Planner to find it. A place you share to StopDash from another app (Google Maps’ Share, say), or open with it, is treated the same way: its name or address goes into To… as if you’d typed it, on your device; a shared point (a geo: link with a position) is the destination of the trip, sent to TfL’s Journey Planner as any destination is. A Google Maps link in what’s shared is read for the place’s exact spot, which is then the trip’s destination like a shared point. A full link names it already, and isn’t opened. A short one (maps.app.goo.gl/…) names it only once followed, so StopDash asks Google once where it leads (once per share while the app runs: a share Android restores after ending the app mid-request, or the same link shared again later, may ask again, the same request): Google receives that link (which names the place you shared, a place it gave you in the first place), your IP address and the app’s user agent, never your location, stops or keys, and handles it under its own privacy policy (https://policies.google.com/privacy). Only Google’s own Maps addresses are followed, and the page the link leads to is never fetched. A link the Maps app shares often leads to the place’s name and address rather than its spot: its postcode is then used as a shared address’s is, found on your device where the bundled list holds it and otherwise looked up with TfL’s Journey Planner, sending only the postcode, as typing it does. If the link can’t be followed (offline, or Google changes it), or names neither a spot nor a postcode, the share’s name is searched instead. The debug log notes only a link that couldn’t be followed, with Google’s HTTP status or the kind of failure, never the link. An address that starts with a house number is looked up in the lists by its street. After a pick, the app sends the chosen station’s id to look up its stops and departures; a place picked in From… sends that place’s position (a public place, street or postcode center from the bundled list, not yours) to find the stops around it, and as the start of any trip planned from it; and the station’s own position (a public place, not yours) to find the stops around it (for To…, the stops and the routes of the lines leaving where you start from; a To… from the near-me list starts from the location the near-me list was found from, which goes to TfL’s Journey Planner as the trip’s start — see Trips with a change — and refreshing it or coming back to the app finds your location again, exactly as the near-me list does). The name isn’t saved or logged. The last eight stations or places you pick from From…’s search list (not your saved places, which are already kept, nor Here, your own position), separately the last eight destinations you pick in To… (a stop, or a place or postcode with its name and map position), and separately the last eight stops you pick in a trip’s Via…, are remembered on the device to list under Recent, in app storage that Android never backs up or transfers; they are never logged or sent anywhere, and clearing the app’s data removes them. So that a starred stop can be listed by name there, the place each starred row belongs to (its stop area or station, as TfL names it) is kept the same way, and forgotten once you unstar it. The search also lists and matches your starred stops and the stops the app has lately shown you, all read on the device; none of that is sent anywhere either.

Lines… (the menu’s Lines…) asks TfL once a day for its public list of lines and keeps it in the app’s cache; what you type is matched against that list on the device and never sent anywhere. Opening a line asks TfL for that line’s status, naming only the line. Opening a stop on its map asks TfL for that stop’s public record, naming only the stop: a tube, rail or tram station’s for its fare zone (kept in memory for a day, never stored), a bus stop’s area for its letter (kept with the routes, below). The last eight lines you open are remembered on the device to list under Recent, in app storage that Android never backs up or transfers; they are never logged or sent anywhere, and clearing the app’s data removes them.

Favorite places (Home, Work, School or a place of your own, saved from Settings) are stored by location. When you add or edit one, the stop or station you type is looked up the way Find a station does it, in the bundled lists of stations, bus stops and London places, streets and postcodes on your device, and sent nowhere. A postcode (what you type is shaped like one and has a digit) is found in the same list, also on the device; one it doesn’t hold (outside London) is looked up with TfL’s Journey Planner, sending only the postcode, and any other place outside London only if you tap Search outside London, sending what you typed. The text you type in the search field isn’t saved or logged, and is sent nowhere else; only the place you then choose is saved — by its coordinate and the name it resolved to (for a postcode, that name may be the postcode itself), the same as choosing a stop. The saved place — its coordinate, its label, and the name of the stop, station, place, street or postcode you chose (shown under the label, e.g. “Oxford Circus”) — is kept on the device with your other settings, so it rides your own Android backup and device transfer like the rest (above); it is never logged or put in a bug report, and deleting the place or clearing the app’s data removes it. Tapping a saved place plans a trip to it from where you are (see Trips with a change below).

Trips with a change (To… from the near-me list or a From… station or place) send both ends of the trip together to TfL’s Journey Planner. A trip from the near-me list starts from your location, the position the near-me list was found from, so the Planner can walk you to whichever stop or station serves the trip best. That is usually the position the nearby-stops lookup has just sent TfL; when the app reused a recent lookup of the same spot instead (below), opening the trip is what sends it; a trip from a From… place starts from that place’s position; a trip from a From… station starts from that station’s stop id, as does Plan again on a trip on the way, which starts from a stop on its route (the one still ahead nearest you, worked out on your device: your location isn’t sent). The destination goes as the stop you picked. When you pick a station complex such as King’s Cross St. Pancras, the Planner is asked once for each of its stations and once for its bus stops, each request carrying the same start. A trip to a saved favorite sends its stored coordinate as the destination — the Planner walks the last leg to it — while the favorite’s name and id stay on your device. To a favorite, or a place or postcode picked in To…, when the fastest route there changes, the Planner is asked once more between the same ends, via the stop that route gets off at, to find one ride the whole way. For a trip from your location (or a From… place) the Planner is also asked again between the same ends via up to three bus stops near the start on the destination’s side (picked on your device from the stops the app carries; one it finds no route through gives way to the next), to find a bus it passed over. A trip to a place (a favorite, or a place or postcode picked in To…) also asks TfL once for the stops near that place’s coordinate, to list the trains from your stops that go straight there; it isn’t asked when you’re already within 200 m of the place. Your location and a favorite’s coordinate are the same Location data the app already shares with TfL, so they add no Play Data Safety category. The Planner is asked when a trip opens, again when you’ve moved on from where it was planned, about every 15 minutes while it stays on screen (every 5 while a route’s arrival can’t be told without a fresh plan), and when you tap Try again; while a trip is on screen, the departures at each stop where a route boards are fetched from TfL like any other stop’s, along with its lines’ status, and, for a ride whose live trains don’t reach as far as you’d get there on a line running a good service, that line’s public timetable between the ride’s two stops (naming only the line and the two stop ids; an answer is held in memory for the day and not asked again that day, while a failed request is asked again about every 5 minutes as long as the trip stays on screen). The plan is held in memory only, never saved or logged beyond coarse diagnostics (a stop id, an HTTP status), and nothing runs once you leave the trip.

Going via a stop (Via… on a trip) sends the station or stop you pick to TfL’s Journey Planner with each of the trip’s requests, as a stop every route must pass: its stop id, or for a station complex such as Finsbury Park the id of each of its stations, one request each. It replaces the requests via the fastest route’s last stop and via the bus stops near the start, which a trip via your stop doesn’t make. A stop id says no more about you than the trip’s two ends already do, so it adds no Play Data Safety category. The stop is kept with the trip while it’s open (over a rotation, or Android closing the app in the background) and forgotten when you leave it or pick another destination. The stop you pick is also remembered on the device under Via…’s own Recent, as described under Find a station; it is never logged (the debug log says only that a request went via a stop, never which).

A later trip (Change time… on a trip) sends the same requests to TfL’s Journey Planner, the ones via bus stops near the start (or via the stop you picked) included, with the date and time you picked, and whether you’d leave then or arrive by then, so the Planner answers from its timetable. It’s planned once when you pick the time, and again only when you tap Try again, change your walking speed, walk limit, step-free level or modes, or move far enough that the trip starts from a different nearest stop; no stop’s departures or line status are fetched for it. The time is kept with the trip while it’s open (over a rotation, or Android closing the app in the background) and forgotten when you leave it; the debug log says only that a planner request was for a later time, never the time.

A trip on the way (after you tap Start on a route) is kept on the device until you arrive or end it: the route’s stops and lines, the leg you’re on and the train followed, and where you chose to go (the destination’s stops, or the position of the place you picked: a favorite, a place or a postcode), in app storage that Android never backs up or transfers, so the trip survives the app being closed. It’s never logged beyond coarse diagnostics (a line id, an error kind, and for a National Rail train the codes of the stations whose boards were asked after it) or sent anywhere, except to your own watch if it has the StopDash watch app (see Your Wear OS watch). If you’ve placed the StopDash widget, its next step and the trains at your next change are kept on the phone for the widget to show (on the lock screen too, if the widget is there), also never backed up, and removed when the trip ends. While a trip is on the way, app open or closed, stopdash asks TfL about every 30 seconds (with the app open, as often as every 10 seconds while you’re moving) where the followed train will call next, by TfL’s own id for that train, and for the departures at a stop where the next leg boards; neither says anything about you that the trip’s departures don’t already. A National Rail train, which TfL has no times for, is followed from National Rail’s own boards, with your National Rail key or, without one, through stopdash’s proxy (which passes on the station codes alone), at up to three stations on its way from where you boarded (usually one: the one it’s due at next), asked for only trains to its terminus: stations along the train’s way, which can include where you board or get off, and where the train ends, and, for a train still a while away, roughly when it’s due where you board. Until it has found your train, it asks the board where you board toward each train there it checks as yours, by its terminus; once you’re on board but it doesn’t know your train yet, it asks the departures at the station just ahead of you, and toward the trains there it checks, the same way: up to three trains checked in all each refresh. It also asks TfL as often for the status of the lines the rest of the trip rides, and (at most every five minutes, shared with the trip’s screen and the list) whether the stops it still has to reach are closed or moved; these name the lines and stops of your route, which is why they’re listed here, and go only to TfL, which the trip already asks about the same lines and stops. Ending the trip, or arriving, deletes it. The “get off soon” alert names the stop and the trip’s destination on your lock screen, like any notification, the “time to board” alert likewise names the line, the stop you board at and the destination, and the “route disruption” alert names a line of the rest of the trip and its disruption, a stop still to reach that’s closed or moved, or a line with no train predicted at the stop you change onto it at, with the destination; you can turn any of them off in Android’s settings for StopDash. While a trip is on the way, an ongoing notification shows its next step, until you arrive or end the trip (or, for a trip left running, four hours after it started). With the watch app, your watch shows the step you’re at in a notification of its own, made on the watch from the trip it already has, and gone when the trip ends. If you’ve allowed location, stopdash takes your precise position about every 30 seconds while you walk to a stop you’re boarding at, only to see whether you’ve reached it, and for the first ten minutes you wait there for your train, only to see whether you’ve already left on another (at a later stop of the ride, or well along it), a few times in the five minutes after your train leaves that stop, only to see whether you got on (you’re still at the stop if not), and a few times as your train nears the station you get off at, only to see whether you’re already there. With the app open, it follows your position as you move instead, every few seconds, for the same purposes and only while one of them applies. Each is compared on the device with the public positions of the ride’s stops (and a station’s entrances), and with where a walk ends to show how far is left, and then dropped: never logged, kept, or sent anywhere. The newest is held in memory for 2 minutes, so a walk that begins in that time can show an estimate of how far it is, and is then let go, or sooner when the trip ends. The last fix on a walk sure enough to show which way its end lies (where it placed you, and how sure it was) is held in memory for at most as long, so a vaguer fix after it doesn’t take the walk’s arrow away.

Starred journeys (two stops you travel between) are kept on the device with your other settings and stars, so they ride your own Android backup like the rest (above); they are never logged or sent anywhere. One that stopdash can’t follow yet (no one line serves both ends, or an end is one of your favorite places) is kept the same way, an end that is a place kept as that place rather than its position; nothing is fetched for it. For the widget, the departures at a journey’s nearer stop, which of them reach the other end, the stops there they get off at, and the names of its two ends, to head it by, are saved with the widget’s other departures on the device. Showing a journey’s trains fetches the departures at its nearer stop from TfL, like any other stop, and at the stops beside it; to find those, and the stops a short walk from the other end, it asks TfL for the stops around each end’s public position (TfL’s own, never yours), as opening a station does, and keeps the answer on the device for up to a day.

Ride alerts, if you turn them on for a favorite ride, keep each direction’s days and times with the journey on the device. During those times stopdash checks in the background, about every 15 minutes, by asking TfL for the status of the journey’s lines (the same request the app makes for the lines near you), and shows a silent notification on your phone naming the journey’s two stops and the disruption. While a bus line has a disruption that may lie elsewhere on its route, the check also asks TfL for that line’s route (the same request opening the route makes, kept on the device for up to a day), so a disruption away from your stops isn’t shown. What each alert last said, and whether you swiped it away, is kept on the device so the same disruption isn’t shown again. It is never logged or sent anywhere, stays out of your Android backup and device transfer (it describes this phone’s notifications), and is deleted when the disruption clears, when the alert’s time window closes, when you turn that direction’s alerts off or remove the journey, or when notifications are turned off. The on-device debug log notes, for each check, when it was due and ran, how many journeys were being watched, the ids of the lines it asked about with TfL’s word for each (“Severe Delays”), and how many alerts it showed or took down; and when the next check is due. It never names the journey’s stops.

Ride alerts are held back while your phone is on a mobile network outside the UK. Each check reads the country of the network your phone is connected to, which Android reports without any permission, and compares it with the UK on the phone. It is never kept, logged or sent anywhere; the on-device debug log notes only that a check was held back.

Ride alerts show only while you’re in London. If you allow location all the time, which the app asks for once you turn alerts on, each background check reads where your phone is and works out, on the phone, whether it’s within 120 km of central London. That check’s position is never kept, logged or sent anywhere; the on-device debug log notes only that a check was held back because you were further away. If you don’t allow it, alerts show anywhere in the UK.

The same permission lets the widget follow you. Each time the widget refreshes on its own (you tap its header, the every-minute refresh is on, or your watch asks), it reads the position your phone last had, without asking for a new one, and shows the stops near there. When those stops aren’t ones the app has looked up nearby recently, it finds the stops around that position on the phone, from the list of TfL’s stops built into the app. That position never leaves your phone: unlike the app, the widget never asks TfL for the stops near you, so away from London it shows the stops the app last found there, or none until you open the app there. A lookup in and around London is remembered on the phone with the app’s own (see below). The widget then asks TfL for the departures at those stops, by their IDs, as it does for any stops it shows; TfL handles those requests under its own privacy policy (https://tfl.gov.uk/corporate/privacy-and-cookies/). The debug log notes only how many stops the widget moved to, never where. Turn it off in Android’s settings, or from Settings → Automatic watch and widget location.

Held in memory only: the last precise (GPS) position, for up to 10 minutes, so a rough network position that comes in while you haven’t moved doesn’t replace it. It is never written to storage or logged, is sent only as the position of a nearby-stop lookup TfL is asked for (outside the area the app’s built-in stop list covers) or as the start of a trip you open from the near-me list (and, when a lookup used it, in a bug report you choose to send, as described below). Past 10 minutes it is no longer used, and it is deleted the next time the app takes a location or when the app’s process ends, whichever comes first.

Wi-Fi at saved places, kept on the phone and in your own backup: when your phone gets a precise (GPS) location within 100 m of one of your saved places (Home, Work, School or one of your own) while it’s on Wi-Fi, stopdash remembers, for that place, the address of the Wi-Fi access point it’s connected to (its BSSID, an identifier of the router, not anything sent over it), and an id for the network’s name: a keyed hash of the name, never the name itself, under a random key made on your phone and kept beside the list (so it goes in your backup with it), and deleted with the list. The name can’t be read off what’s stored, though someone holding a copy of the whole list, key included, could check a name they already suspect. Next time, if the phone can’t get a precise location but is on one of those access points, the near-me list starts from that saved place rather than from a rough network position. On another access point of the same network (an office has many), it does the same when your rough position is within a kilometer of the place. Only the access point’s address and the network’s id are kept, beside the place and where it was; nothing about other networks around you is read, and a metered network (a phone’s hotspot, a train’s Wi-Fi) is never kept. Like your saved places, it leaves the phone only in your own Android backup and device-to-device transfer, key included, so a new phone recognizes your places at once; stopdash itself never logs it, sends it anywhere, or puts it in a bug report (a report you choose to send says when a position came from a saved place’s Wi-Fi, as it says where any other position came from). Turning off Settings → Remember Wi-Fi at saved places deletes it, and removing or moving a saved place deletes that place’s; if you take away precise location, it is deleted the next time you open the app (Android closes the app when you take a permission away, and never gives it the access point’s address without precise location). Reading which network your phone is on needs Android’s network state permission, granted at install without a prompt; Android counts the read as a use of your location.

Kept on the device, never backed up: to skip a repeat stop lookup when you reopen the app near where you last used it, stopdash keeps the positions of its last few nearby-stop lookups (up to four places) and the stops found around each, for up to a day, in the app’s cache directory. Android never includes that directory in a backup or device transfer, it is never logged or sent anywhere, and clearing the app’s cache removes it; an entry older than a day is deleted the next time the app looks up nearby stops. The stops found near the places your trips go to are kept the same way, in a file of their own (up to four places, for up to a day).

The routes and stop areas the app fetched (a line’s stops, and the stops grouped with a journey’s starting stop) are kept the same way, for up to a day, so reopening a route doesn’t ask TfL again. They are TfL’s public network data, but which ones are there says which routes you looked at, so they stay in the app’s cache directory too: never backed up, logged, or sent anywhere, and an entry older than a day is deleted the next time the app starts or looks up a route or stop area. The branching lines’ current routes, which the app fetches for everyone to label branches (the Northern, Central and Piccadilly lines), are kept there too, where they differ from the routes built into the app, until a later fetch replaces them; they say nothing about you.

Crash reports and usage stats (opt-in)

If — and only while — you turn on Help make StopDash better in Settings, stopdash sends crash reports to Firebase Crashlytics and usage statistics to Google Analytics for Firebase (Google). It is off by default: nothing is collected until you turn it on, and a crash from before you did is discarded rather than sent (if one is waiting, reporting starts the next time you open the app). Until you’ve answered, the app asks once, with a card at the top of the stops near you: Yes please turns it on, No thanks keeps it off, and either way the card doesn’t come back. You can change your answer in Settings at any time.

What it sends:

What it never sends: your location (coordinates), the stops or stations near you, your starred rows or journeys, what you searched for, or your TfL API key. stopdash strips the advertising-ID permission, so the advertising ID isn’t collected either.

Turning it off stops collection at once, discards any crash report not yet sent, and resets the Analytics app-instance ID. The choice is kept on this device only: restored onto a new phone from a backup, it starts off again until you turn it back on. Development (debug) builds never send anything. Firebase is free at stopdash’s scale; uploads are batched by the SDKs, with no extra wakeups or location requests. For the Play Data Safety form this adds Crash logs, Diagnostics, App interactions, Device or other IDs and Approximate location (the region Analytics infers from your IP address), all optional (user-controlled).

The on-device diagnostic log

StopDash keeps a diagnostic log on the device so a misbehaving routing or departure decision can be explained — for example, why “couldn’t get your location” appeared, or why a line showed “couldn’t check for disruptions”. Diagnosing those needs a record of what the app saw, so the log carries coarse state and reasons, and nothing more:

The log never carries:

These diagnostics are written to Android’s Logcat (visible to a developer with the device connected) and to a persisted log file on the device — a small rotating file in the app’s private cache (excluded from backup), kept so that a crash or a silent process kill still leaves a record of the last thing the app saw. It holds the newest five runs of the app; sending a bug report doesn’t delete them, so a later report may include some of the same lines. The persisted log stays on the device. The one off-device destination is Crashlytics, and only while you’ve opted in (above): it receives the log’s off-device rendering, with every stop ID, line ID and coordinate replaced by ••• before it leaves the app. The logging runs through one shared on-device buffer (mikelward/androidlog), wired incrementally: a feature whose warning seam isn’t connected yet is discarded rather than recorded.

Two ways to get the log off the device for a bug report are foreseen, and they draw the privacy line differently. A location-safe export — the log shared with its travel data (stop IDs and line ids) redacted, since a shared file is otherwise subject to the same rule as any other artifact that leaves the machine (AGENTS.md Privacy) — is still planned (TODO.md). The other is the consent-gated bug report described next, which does the opposite on purpose: it keeps the location in, openly and under consent, because that is the context a routing bug is diagnosed from.

Sending a bug report

StopDash can send a bug report from its overflow menu. This is the one channel that deliberately carries what the on-device log never does — so it is gated by an explicit consent screen that names exactly what leaves, and nothing is assembled or sent until you pass it. The report carries:

It is user-initiated and £0: stopdash runs no service of its own for it. Tapping Send bug report opens the consent screen; on Continue the report is copied to your clipboard (on-device, but readable by other apps from then) and handed to Android’s share sheet, where you choose the app it goes to — an email, an issue, a chat. So the clipboard copy happens as soon as you tap Continue; nothing is sent to a destination you pick until you pick it, but the report has left the composing screen at that point. A “don’t ask again” option skips the consent screen on later reports; it never sends anything on its own, and it lapses whenever the report starts carrying more, so you see the new list before it is sent.

This is an honest trade, not a location-safe one: a report useful for a where did routing go wrong bug has to say where you were, so this one says so plainly rather than stripping the context to look safe. For Play Data Safety it is a user-initiated share of app diagnostics, a screenshot, and a coarse-or-precise location to an app you choose — disclosed here as such.