Learn
A structured curriculum for engineers building on AAOS. Every topic links straight into AOSP source on cs.android.com and the platform docs, so you can go from concept to the actual implementation in one click.
Lookup material rather than reading material — for when you know what you need.
Every one of the 280 vehicle properties Android Automotive defines, generated directly from VehicleProperty.aidl. Search by name or hex ID, filter by area, type and access, and jump straight to the AOSP source for any of them.
What Android Automotive actually is, how the stack is layered, how to get a build running, and the programme rhythm the work happens in.
Start here. The single most common confusion in this field, cleared up slowly — with everyday comparisons, a worked example, and what each one means for the code you will actually write.
10 min read
A map of the whole platform, explained one layer at a time — what each layer is for, who writes it, and a worked example following a single temperature reading from a sensor in the car to the number on the screen.
11 min read
The complete boot sequence, stage by stage — from the ignition signal through the bootloader, kernel, init and Car Service to the home screen, and why one missing component stalls the whole thing.
8 min read
Syncing AOSP, choosing an automotive lunch target, building the emulator image, and the hardware you actually need — plus honest numbers on disk, RAM and time.
4 min read
The inflection points that matter when you inherit a codebase — HIDL to AIDL, the Car UI Library, occupant zones — and how to work out what your platform version actually supports.
4 min read
Sample phases, freeze dates, start of production and a fifteen-year support tail — the rhythm that explains why platform work is scheduled the way it is.
4 min read
The Vehicle HAL: property anatomy, areas, access modes, subscriptions, writing your own, and migrating from HIDL to AIDL.
The single doorway between Android and the car, explained slowly — what a vehicle property actually is, why the interface is so small, and the three fields in a config that cause most bugs.
11 min read
That hex number is not a serial number — it is four facts packed into 32 bits. Learn to read one by eye and a large part of VHAL debugging becomes arithmetic instead of guesswork.
8 min read
One cabin temperature reading, followed through every hop — thermistor, ECU, CAN frame, kernel driver, vendor service, VHAL, Binder, Car Service, app, screen — with the mechanism named at each boundary.
10 min read
The complete path for a new vehicle property: ID, config, HAL implementation, permission, SEPolicy and the app that finally reads it — plus every place it silently fails.
5 min read
The framework side of the vehicle interface — connecting to Car Service, subscription rates, error semantics, and the lifecycle bugs that only appear on a real head unit.
5 min read
Driving properties by hand, reading dumpsys output, injecting values into the reference HAL, and building a simulator so you stop waiting for a vehicle.
5 min read
What actually changes when the Vehicle HAL moves interface technology — batched requests, a new callback model, and the compatibility strategy that keeps a shipped vehicle working.
4 min read
What actually happens between a HAL publishing a value and forty apps receiving it — deduplication, rate arbitration, variable update rate, and the power cost of getting it wrong.
4 min read
The properties that do not fit one number — configArray conventions, vector types, backported properties, and when to stop bending the model and add a service instead.
4 min read
The property set that only exists on an EV — battery level, charge state, port status, range — and why an estimate the driver does not trust is worse than no estimate at all.
7 min read
Why positioning in a car is both better and harder than on a phone — satellite fixes, dead reckoning through tunnels, wheel ticks, and the sensors Android does not own.
6 min read
CarService internals, the android.car API surface, occupant zones, watchdog, telemetry, and adding a subservice of your own.
Every car API call crosses a process boundary. What that costs, what a Parcel is, why thread pools run out, and why a slow Vehicle HAL shows up as jank in an unrelated app.
10 min read
The system service that owns vehicle state, audio, power and users — how it starts, how its subservices fit together, and how to read its dumpsys output like a professional.
5 min read
Which manager owns what, which permission each needs, and how to work out whether the thing you want to build is even possible on AAOS.
4 min read
Why user 0 never reaches the screen, what actually happens during a user switch, and the assumptions from phone Android that will break your automotive app.
5 min read
Seats, displays and users as a graph — how a cockpit with three screens and two logged-in people is modelled, and what breaks when you assume there is one of each.
3 min read
The service that pings your process, counts your disk writes, and kills you when either goes wrong — plus how to stay on the right side of it.
4 min read
CarTelemetryService for platform metrics, CarDiagnosticManager for OBD-II frames, and the privacy boundary you must not cross when collecting either.
4 min read
The full shape of an OEM system service — AIDL, manager class, registration, permissions, dump() and the threading rules that keep Car Service alive.
4 min read
Getting the time right in a vehicle is genuinely hard — three different clocks, no network for weeks, a driver who crosses borders, and a timestamp field that fails silently if you pick the wrong one.
6 min read
CarSystemUI, driver distraction rules, theming, notifications, the launcher, and the input devices phones never had.
The system bars, HVAC panel and notification surface an OEM inherits and must make its own — what CarSystemUI owns, and where your app's pixels actually begin.
4 min read
The framework enforces safety rules on your UI whether you cooperate or not. What the restrictions are, how they are configured, and how to build an interface that degrades gracefully.
4 min read
How one AOSP codebase produces a Volvo, a Polestar and a GM head unit — component libraries, runtime resource overlays, and the discipline that keeps them maintainable.
4 min read
Ranking, heads-up rules, read-aloud and the distraction filter — why a notification that works on a phone can be invisible, silent or blocked in a car.
3 min read
How apps are discovered, categorised and blocked — the manifest metadata that decides whether your app appears at all, and why the app grid is not a phone launcher.
4 min read
Not every head unit has a touchscreen you can reach. How AAOS models non-touch input, and how to build a UI that works with a rotary knob without redesigning it twice.
4 min read
Screen readers, large text and switch access in a car — where automotive accessibility differs from a phone, and why the distraction rules and accessibility rules sometimes pull in opposite directions.
6 min read
Where every vehicle configuration surface lives — adding an entry, keeping it usable while driving, and deciding whether a setting belongs to the car, the driver, or neither.
5 min read
Building the apps drivers actually use — media, navigation, assistant — and the template system that keeps them safe.
You do not draw the UI — you serve a browse tree and a session, and the car renders it. The contract, the constraints, and the mistakes that make an app unusable while driving.
4 min read
Navigation, point-of-interest and IoT apps are built from templates, not layouts. What the constraint buys you, what it costs, and how the template host actually works.
4 min read
The navigation template, the map surface, and pushing turn-by-turn instructions to the instrument cluster so the driver never looks at the centre stack.
3 min read
The only interaction model that is genuinely safe at speed. How the assistant slot works, how apps expose actions to it, and why voice is not a feature you bolt on.
3 min read
Play Store on GAS builds, OEM stores, system-image inclusion and sideloading for development — four very different routes with very different timelines.
4 min read
The rear-view camera path, the instrument cluster, and the multi-screen cockpit — where AAOS stops looking like Android.
A legally mandated image in under two seconds, on a system that takes fifteen to boot. How the Exterior View System bypasses the framework, and hands over once Android is ready.
4 min read
Two architectures, one screen behind the wheel — cluster as an Android display, or cluster as a separate safety-rated system Android talks to. What changes for you either way.
4 min read
Passenger displays, rear entertainment and shared surfaces — configuring displays, moving activities between them, and the assumptions that break when there is more than one screen.
3 min read
The smallest screen with the strictest rules — projected onto the windscreen, in the driver's forward view, where anything unnecessary is a hazard rather than a feature.
4 min read
A camera pointed at the driver, becoming a regulatory requirement in several markets — how it is architected, why the images never reach Android, and the privacy rules that are not optional.
6 min read
Lane keeping, adaptive cruise and emergency braking run on their own safety-rated hardware. What Android receives, what it must never do, and how to display a system you do not control.
6 min read
Zones, contexts and buses — why car audio is a routing problem before it is a playback problem.
Zones, contexts and buses — why car audio is a routing problem before it is a playback problem, and how the configuration file decides everything.
5 min read
Who gets to be heard, what happens to everyone else, and why the sounds that matter most are the ones that must never be interrupted.
4 min read
Below CarAudioService: how buses are declared to Android, how the policy engine picks a device, and why an address mismatch produces silence with no error anywhere.
4 min read
Bluetooth profiles, hands-free calling, eCall, and the modem that keeps the vehicle online for fifteen years.
Four profiles, one paired phone, and a driver who blames the car when any of them drops. Pairing policy, profile priorities and the reconnection behaviour that decides perceived quality.
4 min read
Calls routed through the vehicle, and the emergency call the vehicle places by itself — a regulated function that must work when everything else has failed.
4 min read
A modem that must work for fifteen years across network generations, a data budget somebody pays for, and a vehicle that is offline more often than it is online.
4 min read
Unlocking a car with a phone — how the standard works, why Android is deliberately outside the trust path, and the failure case that must always work.
6 min read
The confusing case: a car running Android Automotive that also hosts Android Auto or CarPlay. Two Androids, one screen, and the handover rules between them.
5 min read
The power state machine, Garage Mode, and the boot-time budget an OEM will hold you to.
A head unit is never really off. The CPMS state machine, what Garage Mode is for, and why boot time is the metric an OEM will hold you to.
5 min read
The milestones an OEM measures, where the seconds actually go, and the changes that move the number — as opposed to the ones that feel productive.
4 min read
Memory pressure on constrained hardware, binder saturation, jank, and profiling with Perfetto.
Head units ship with the RAM the bill of materials allowed, not the RAM you wanted. What lmkd kills and in what order, and how to keep your process out of the queue.
4 min read
Jank, binder saturation and the scheduling problems that only appear on a loaded head unit — how to capture a useful trace and what to look for in it.
4 min read
The driver does not measure milliseconds — they notice hesitation. What to optimise, what to fake honestly, and the budgets that make a head unit feel solid.
4 min read
Where everything lives on a head unit, and why the flash memory has a write budget that must last fifteen years — the constraint that explains CarWatchdog and Garage Mode.
6 min read
SELinux for vehicle HALs, the car permission model, verified boot, and the keys that sign a vehicle image.
Why a correct HAL still returns nothing, how to read an AVC denial, and the policy you must write for any process that touches the vehicle network.
4 min read
Which permissions an ordinary app can hold, why anything that actuates the vehicle is signature-level, and the partition rules that will not bend for your schedule.
4 min read
How a vehicle refuses to run software that is not its own — the chain of trust from the bootloader to /system, and what happens when a link is broken.
4 min read
Which key signs what, why the AOSP test keys must never leave a lab, and how app signing works when the OEM owns the platform key.
4 min read
CTS, VTS and the CDD, functional safety, automotive cybersecurity regulation, and what actually blocks a launch.
What 'Android compatible' actually means, which suite tests which layer, and how compliance failures block a launch — usually late, and usually predictably.
4 min read
What ISO 26262 actually asks for, why Android is almost never the safety-relevant component, and how to recognise a requirement that has been assigned to the wrong system.
4 min read
Unlike functional safety, this one lands squarely on Android. Type approval now requires a cybersecurity management system, and that has concrete consequences for how you build and update.
4 min read
The approval process that decides whether a vehicle can be sold in a market — and the surprising number of software behaviours it constrains.
3 min read
VSS, AUTOSAR, SOME/IP and Eclipse Kuksa — bridging the vehicle network to the Android middleware.
The Vehicle Signal Specification as a shared contract between ECU, platform and HMI teams — and how to test the whole signal path without a vehicle.
5 min read
The service-oriented transports replacing signal-oriented CAN, and how AAOS runs as one guest among several on a modern vehicle computer.
4 min read
Soong, product configuration, build infrastructure that scales, and shipping an update to a vehicle in the field.
How AOSP actually builds — blueprint files, modules, visibility and the partition a module lands on. Enough to add a module and understand why yours does not build.
3 min read
Product config, device config and board config — how a lunch target becomes an image, and where to put the hundreds of settings that make a head unit an OEM's rather than AOSP's.
3 min read
Full builds take hours and there are dozens of engineers. Caching, incremental strategy, artefact management and what to actually gate on.
4 min read
Updating a vehicle in a customer's driveway, with no way to recover it if the update fails. Seamless updates, rollback, and the constraints a metered link and a parked battery impose.
4 min read
Below Android entirely — how the kernel learns what hardware exists, why a new board shows a black screen, and the layer where automotive projects lose the most schedule.
6 min read
The commands that tell you what the platform is doing, and automation that survives a real head unit.
The commands that actually tell you what the platform is doing — a triage order that resolves most AAOS defects before you open an IDE.
5 min read
Espresso, UI Automator and the vehicle state your tests must fake. Building a suite that runs on real hardware and does not become the thing everyone ignores.
3 min read
When a process dies or freezes, Android leaves behind a detailed record. Reading it turns 'the head unit rebooted' into a specific line of code.
6 min read
What to log, at what level, and where it goes — balancing a defect you may only ever see once against flash memory that has to last fifteen years.
6 min read
