Stippl is de sociale AI-reisplanner. Onze Android ANR-rapporten lieten zien dat de app bij het opstarten vastliep in code die vóór de onze draait: Firebase die zijn SDK's start en Mapbox die zijn kaartbibliotheek laadt. We stopten een alarm dat de app elke 15 minuten startte, haalden een SDK weg die niemand aanriep en lieten de kaartbibliotheek pas laden als er een kaart opent. De vastlopers bij het opstarten gingen naar nul met het alarm, een build vóór de rest.
Tussen 10 oktober en 9 november registreerde Google Play een Android ANR voor 408 reizigers die Stippl gebruikten. Bij 67 van hen, 16%, liep de app vast in de eigen start van Firebase, voordat onze application class draaide en voordat er ook maar iets van onze JavaScript geladen was. Een van de SDK's die daarbij werd gestart, hadden we nooit aangeroepen.
Hier lees je waar die opstarttijd heen ging, wat we eruit haalden, de fix die onze splash screen 32 seconden liet hangen voordat hij bij iemand terechtkwam, en waarom het getal dat het meest bewoog van de wijziging kwam die ik voor het makkelijke werk hield.
Vóór onze eerste regel
ANR staat voor Application Not Responding. De main thread van de app bleef zo lang geblokkeerd dat Android niet meer wilde wachten, en bij een start waar je naar kijkt biedt het aan de app te sluiten. Google Play telt ze per app en laat apps met te veel ervan aan minder mensen zien. Play telt alleen telefoons die diagnostiek delen, dus elk getal hier is een steekproef, niet iedereen.
Onze vastlopers bij het opstarten waren niet nieuw: ze zaten op ongeveer hetzelfde niveau in elke build die we bekeken, terug tot 3.1.5. Ze waren de prijs van het starten van de app zelf.
We lazen de traces via de Developer Reporting API van Play, die de volledige stack van elk gesampled rapport geeft in plaats van één regel met een schuldige. Op 3.1.11 maakten drie families het grootste deel uit van wat overbleef: Firebase die opstart (19% van de reizigers met een ANR), het laden van de Mapbox kaartbibliotheek (15%) en onze eigen MainApplication.onCreate (13%).
De eerste twee komen nooit in onze code. Als Android een proces start, bindt het de application en draait het elke content provider die het samengevoegde manifest declareert, vóór Application.onCreate. SDK's gebruiken die hook om zichzelf te starten: Firebase via FirebaseInitProvider, Mapbox via androidx.startup van Jetpack. Het gebeurt bij elke processtart, ook bij de starts die niemand ziet, zoals een pushbericht dat binnenkomt terwijl de app dicht is.

Wat er draait vóór onze eerste regel
Alles boven onze application class is code die we niet schreven en die we in één geval nooit aanriepen. Op een trage telefoon is de som daarvan de vastloper. En je betaalt het bij elke processtart, dus de andere vraag is hoe vaak de app start.
De app minder vaak starten
De eerste fix zat in onze eigen code en ging als eerste de deur uit, in 3.1.13. Ons dagboek synchroniseert foto's op de achtergrond met een taak die Android elke 15 minuten vanuit een alarm draait, en elke start van de app registreerde die taak, voor elke reiziger. Als de app niet draaide, was elk alarm een volledige processtart: Firebase, de bibliotheek van Mapbox, onze application class en een JavaScript runtime zonder scherm, voor een sync die bijna nooit iets te doen had. Tussen 10 oktober en 6 november kwamen 134 van onze 498 Android ANR-rapporten, 27%, van die alarmstarts.
Nu bestaat de taak alleen nog zolang er een dagboekitem op synchronisatie wacht. Een check bij elke start, en aan het einde van elke sync, registreert hem als er iets wacht en haalt hem weg als er niets wacht. Android bewaart het alarm over een app-update heen, dus een installatie die het had, verliest het bij de eerste start van de nieuwe build, of zodra het alarm na de update voor het eerst afgaat. Foto's die vlak voor het sluiten van de app zijn toegevoegd, krijgen nog steeds het alarm, en de sync draait ook als de app start, naar voren komt of inlogt.
Ik zag dit als het makkelijke deel: achtergrondruis opruimen voor het echte werk aan het opstarten. De getallen verderop zeggen iets anders.
De SDK die niemand aanriep
Geen enkele aanroep van Firebase was traag. In elke trace was de main thread bezig in de startcomponent van de volgende SDK: Sessions, Crashlytics en zijn native crash loader, component discovery, Auth, de Analytics connector, Performance Monitoring. Samen was dat te veel voor een trage telefoon.
De meeste daarvan wegen zwaar. Ze geven ons push, inloggen, crashrapporten, analytics en remote config, en ze lazy maken zou betekenen dat we Firebase moeten patchen. Dus stelde ik een kleinere vraag: welke gebruiken we eigenlijk?
Performance Monitoring kwam in juni 2024 binnen als dependency, en sindsdien heeft geen enkele JavaScript het aangeroepen. Een zoektocht door de hele repository vond het op drie plekken: de pakketlijst, zijn config plugin en een iOS linking lijst. Geen import, geen wrapper, geen firebase.perf(). Onze eigen documentatie zei dat we het gebruikten. Het kwam toch voor in 8 van de 61 Firebase-traces.
Het uitzetten van de verzameling zou niet hebben geholpen. De vroege component, FirebasePerfEarly, draaide bij elke start met firebase_performance_collection_enabled op false. Dus de module moest uit de Android build: één regel in package.json, expo.autolinking.android.exclude: ["@react-native-firebase/perf"], en de config plugin die de Gradle plugin toepaste is weg. Een test met de naam "Firebase Performance on Android is not autolinked and its Gradle plugin is not applied" faalt als een van beide terugkomt.
De gemeten winst is klein, en dat zeg ik liever. Op de emulator ging de tijd van Firebase op de main thread bij de start van 66 ms naar 61 ms, de middelste waarde van zeven starts ervoor en zes erna, en het eigen aandeel van Performance van 6,6 ms naar nul. Met de host onder zware belasting nam die ene component 125 van 688 ms. Ik verwacht dat het ongeveer een achtste van de Firebase-familie scheelt, niet dat het die oplost. De rest van Firebase blijft op de main thread tot we de start kunnen verplaatsen zonder te racen met elke SDK die hem nodig heeft.
Wat we hebben opgegeven zijn de Android-gegevens in de Firebase Performance console, die niemand las. Opstart en schermtijden op Android bereiken ons nog steeds via Sentry.
De kaart laden als er een kaart opent
Mapbox tekent de reiskaart in onze reisplanner, en het was de tweede familie. In Crashlytics was het één soort telefoon: 26 vastlopers van 25 reizigers tussen 25 oktober en 8 november, allemaal een Xiaomi met Android 16. De traces lieten zien dat de startup initializer van Mapbox zijn native bibliotheek laadde, System.loadLibrary("mapbox-maps"), op de main thread. Elke processtart betaalde voor een kaart, ook een pushbericht dat binnenkwam terwijl de app dicht was.
De fix zag er klein uit. Een config plugin haalt de twee startup initializers van Mapbox uit het samengevoegde manifest met tools:node="remove", en het access token wordt gezet als de eerste kaart rendert in plaats van als de module wordt geïmporteerd. Als de startup-hook niet is gedraaid, nemen de klassen van Mapbox een lazy pad en initialiseren ze bij het eerste gebruik. Dat hadden we in de bytecode gelezen.
De fix die de splash liet hangen
De eerste Android testbuild ermee kwam nooit voorbij de splash screen. Op de emulator gaf am start -W het na 32 seconden op.
Eén klasse nam het lazy pad niet. LocationServiceImpl leest de common context van Mapbox in zijn static initializer, en de enige code die die context zette was de startup-hook die we net hadden weggehaald. Onze kaartbibliotheek maakt zijn locatiemodule aan zodra de JavaScript bundle de bibliotheek importeert. Dus de import crashte, React Native registreerde de app nooit en de splash bleef staan.

Waar het hangen vandaan kwam
De initializer terugzetten had de helft van de vastlopers teruggebracht. In plaats daarvan zet één regel in de patch die we al voor de kaartbibliotheek bijhouden de context als de location manager start: MapboxSDKCommon.invoke(context.applicationContext). Het is een schrijfactie naar een statisch veld, zonder native load. Daarmee startte dezelfde build cold in 2,4 seconden, daarna 1,9 en 1,7. Een build van dezelfde commit zonder de patch hing op dezelfde manier, dus de patch is wat het oploste.
Nu laadt de common bibliotheek op een achtergrondthread als de JavaScript start, laadt de kaartbibliotheek op de main thread als de eerste kaart opent, en laadt een start zonder scherm, zoals een push, geen van beide. De testbuild ving het hangen op, en geen enkele reiziger heeft het gezien.
De cijfers erna
3.1.14 staat sinds 14 november op Google Play. De cijfers van Play lopen ongeveer twee dagen achter, dus wat ik heb zijn de eerste vier dagen, 15 tot 18 november. Een reizigersdag is één telefoon die de app op één dag gebruikt. Per build heb ik de ANR-rapporten van Play gesorteerd op wat de main thread aan het doen was, en geteld over de dagen dat die build in gebruik was: 3.1.11 van 29 oktober tot 10 november, 3.1.13 van 8 tot 18 november, 3.1.14 van 15 tot 18 november. Zo meten de kolommen hetzelfde.

Vastlopers bij het opstarten, build voor build
De vastlopers bij het opstarten waren weg een build vóór de fixes waar dit artikel grotendeels over gaat. 3.1.13 veranderde één ding aan hoe de app start: het alarm. Firebase was hetzelfde als in 3.1.11, en toch liep van 8 tot 18 november geen enkel rapport vast in de start van Firebase of in onze application class, waar het niveau van 3.1.11 er ongeveer 46 voorspelt. Drie van de vier Mapbox-vastlopers die op 3.1.13 overbleven kwamen van het alarm zelf, op telefoons waar de update het nog niet had weggehaald.
3.1.14 houdt dat alles op nul in zijn eerste vier dagen, en geen van zijn drie ANR-rapporten heeft een Firebase Performance frame. Sentry, onze tweede bron, laat dezelfde daling zien in ANR events van elk type: 69 op 3.1.11, 5 op 3.1.13 en 3 op 3.1.14 tot nu toe.
Dus ik kan je nog niet vertellen wat de SDK die we weghaalden en de lazy kaart erbovenop toevoegen. Op deze cijfers deed de app minder vaak starten het meeste werk. Waarom het ook vastlopers wegnam bij starts die een reiziger maakte door op het icoon te tikken, kan ik maar deels verklaren: een tik die landt op een proces dat het alarm nog aan het starten is, wacht achter die start. Of dat alles is, laten de cijfers niet zien. Ik voeg aan het eind van november twee volledige weken van 3.1.14 toe.
Ter vergelijking: de 7-daagse ANR-rate van Play, het cijfer waarop de store rangschikt, was 0,15% op 13 november, de laatste dag vóór 3.1.14, en 0,07% op 17 november. Hij had een piek van 0,84% op 3 november om een andere reden, een animatiebibliotheek die volledige stack traces op de main thread schreef, gefixt in 3.1.11.
Wat ik anders zou doen
Drie dingen.
Ik zou kijken hoe vaak de app start voordat ik kijk hoe lang elke start duurt. Ik zag het alarm als ruis die ik moest opruimen voor het echte werk en ging achter de SDK's aan. De getallen zeggen het andersom. Dat ik dat kan zeggen komt doordat de twee in aparte builds uitkwamen, een week uit elkaar. Waren ze samen uitgekomen, dan had deze tabel de eer aan de SDK's gegeven.
Ik zou opschrijven wat zichzelf start voordat ik iets aan de app toevoeg, en die lijst onder test houden. Het samengevoegde manifest zegt precies welke content providers en startup initializers draaien. Niets vertelde ons wanneer die lijst groeide. We testen nu dat Performance Monitoring niet terugkomt; de hele lijst testen we nog niet.
En ik zou geen opstartwijziging mergen die alleen gelezen is. Het plan klopte, en het lezen klopte voor elke Mapbox-klasse op één na. Onze eigen notities bij de eerste fix zeiden "in de bytecode gelezen, nog niet gedraaid". Die zin was het risico, opgeschreven. Hier kostte het een testbuild en ongeveer een dag. In een storebuild was het elke Android-reiziger geweest die updatete, vast op de splash.
De conclusie
Een dependency die niemand aanroept, is nog steeds code die bij de start draait, en elke start betaalt ervoor. Tel dus eerst hoe vaak je app start als niemand erom vroeg, en stop die starts. Lees daarna wat zichzelf start vóór je eerste regel en haal weg wat je niet gebruikt. En start een release build op een echt toestel voordat je het lazy pad vertrouwt dat het vervangt.
Ik zag het alarm als het makkelijke deel. De cijfers zeggen dat het het meeste werk deed.Robin, CTO van Stippl
Vragen die mensen stellen
Wat veroorzaakt ANR's bij het opstarten van een Android-app?
Werk op de main thread vóór het eerste scherm. SDK's die zichzelf starten via een content provider of androidx.startup draaien bij elke processtart, vóór Application.onCreate, ook bij starts op de achtergrond die niemand ziet, en op een trage telefoon is hun som genoeg voor Android om de app als niet reagerend te melden.
Stopt het uitzetten van Firebase Performance Monitoring het opstartwerk op Android?
Niet in onze build. De vroege component draaide bij elke start, ook met het verzamelen uitgezet, dus we haalden de module uit de Android build.
Hoe laat je de Mapbox SDK op Android lazy laden?
Haal de twee androidx.startup initializers uit het samengevoegde manifest en zet het access token als de eerste kaart rendert. Elke Mapbox-klasse die vóór dat moment zijn common context leest, heeft die context eerst nodig, anders kan de app bij de start blijven hangen.
Stippl is de sociale AI-reisplanner. Reizigers beschrijven een reis in hun eigen woorden, de AI maakt het plan, en de mensen met wie ze reizen doen mee om samen te plannen, te boeken en te delen. Meer dan 1,5 miljoen reizigers hebben hun reizen met Stippl gepland. Het is gratis op iOS, Android en het web.



