Yes, so let me just reiterate what I just said for those people, listen to the recording
later on.
So a quick look at released names, tags and build numbers, and I'll try and describe how
they all knit together.
So we're going to be looking at the major versions, the code names, the API levels, the
quarterly platform releases, build IDs, and I'll have a quick look at, get branches
and tags.
So the first bunch are relatively straightforward.
So starting with the major version, by this, I'm talking about things like Android.
5.0 or 16.0, which is the latest of whatever.
So this is the official name of Android, and this is the name or the number used by
the marketing department.
So we all know that.
Next there is the code name.
So ever since Android 1.5, which was called Cupcake, every Android release has had a code name,
do not throw you a current member of the exact sequence, slightly pop was one of them, and
they're being alphabetically incrementing more or less.
So the code name is important because this is the name used by the Android developers.
So they will refer to Android U, Android T, or whatever, being the first letter of the code
name.
And then there's the API level.
So the API level is a number which describes the version of the Android API used by
application programmers.
It started with one, and we're currently up to 36.
So whenever there was a change of the Android API, they have to increment the API number.
Usually by one, but not always, as we'll see in a minute or two.
And this is the identifier used by app developers.
So already you can see the three different ways that three different groups of people are
referring to Android.
Next I want to talk about the quarterly platform release or QPR.
This came about year with Android 12, and the idea is that there are four quarterly platform
releases per year called, well, so we have the major release.
And then that's followed by actually three quarterly platform releases to give you four
or together, and these are QPR one, two, and three.
And originally they were sequence like this.
So the major release would be in quarter three, typically September.
And then the QPR's would be in quarter four, and then quarter one and quarter two over
the next year.
For reasons, Google decided with Android 16 to change that, so everything jumped forward
one quarter.
So with Android 16, the major release was in quarter two, which was may, I think.
And then the QPR's are in quarter three, four, and then quarter one the next year.
And then looking at the API level, so the API level, remember, has to be bumped every
time they change or extend the Android API.
So it used to be that the API level was only bumped on the major release.
But once again, with Android 16, that changed.
So now there's an API bump on both the major release and the QPR-2 release.
So roughly six months apart.
No, down to the bottom here, there were some minor releases.
So there was a 5.1 and 8.1 and the 12.1.
And in each case, there was an API bump with each one of those.
But they don't happen every year.
And then we have the build ID.
So the build ID is an alpha numeric string, which uniquely identifies this build from
the Android development teams build service.
So a build ID looks like that number up there, VP4, a dot, something, dot something.
And there's a description here, which I got actually from the build numbers page, which
says, what those various bits mean.
So now we can put that all together in this wonderful table, which is matching the
version number, the code name, the QPR, the year, the quarter, the API and the build ID.
So a couple of things to note here.
First of all, then, looking at the build ID, it used to be that the first letter of
the build ID matched the Android code.
So T for T are a messu, U for upside down cake.
Then things fell apart a little bit when we got to Android 15.
So notice here then that things changed, things changed in the first quarter of 24.
So we went from U something to A something.
So at this point they decided to reset the build ID, and as this says down here, from
this point onwards, the first letter of the build ID actually isn't the code name of
the Android, it is in fact the year number.
So A is 24, B is 25, et cetera.
And then the digit following that, so we have some of that AP something, the digit is the
quarter number.
I'm actually going to just hold this, really don't work too well.
So now we have AP1, AP2, AP3, AP4, so 1, 2, 3 and 4 are the quarters in the year, remember
A is 24, so those are quarters in 24 in that particular case.
Then things kind of synchronize up a little bit, so we go from AP4 to BP1, which is the
first quarter of 25.
And then when we got to Android 16, they decided to synchronize the code names with the
build numbers.
So that's why Android 16 is something being with B, the clover in fact, A got completely
missed out, poor all day.
So I assume that Android 17, which will come out quite soon, will have a name beginning
with C.
What else, oh yeah, the other way I think to notice here is that the APR level has always
been essentially an integer, but now it's actually a float.
It's actually 16, sorry, 36.1, okay, fair enough, why not, okay, what next?
Now I want to relate this to the, to the Git repositories and how you use this information
to get the version of the code that you actually want.
So quick reminder, this is how you get Android, you do a repo in it, minus U and the URL
to the manifest, minus B, the branch, or actually more likely a tag from the Git repositories
that you want.
So in order to get anywhere with this, then you need to do a mapping between the build
ID that you want.
So if from my previous chart you decided which build ID you want, you need to map that
on to a Git tag, and that is done by this page here called build numbers.
So this is at source.android.com, and you can see the build IDs, hmm, excuse me, and the
corresponding Git tags.
So these are the tags relating to Android 16.
Okay, and you can see, so B is 2025, 2 is quarter 2, and then up there we have a BP3 and a BP4,
which is in quarter 4, 2025.
So to turn this into a suitable example, supposing I want to get the code for Android 16
QPR2, how do you do this?
So you need to work out what the build ID should be, so going back to here,
to the QPR2, so I'm looking for this one here, so that is a BP4A something.
So we need to find something that matches that.
So looking in this, we see that the top there is a BP4A dot something, and that has the tag
Android 16R4, so that is the code for QPR2.
And so to get the code, you do this repo in here, blah, blah, blah, blah, minus B, Android 16R4.
I was going to, well, yeah, there's been some issues with the regularity of releasing
the code, the QPR, the Android 16 QPR1 code was not released for a long time, but the
QPR2, I think, was released more or less on schedule, there we go.
Find a thing I want to mention then, have a quick look at the security releases.
If you look through the get tags, you'll see things like Android, that's security, that's
something, for example, 16R1.
So these security releases are based on the original major release of, in this case, Android
16, and they have only the security bug fixes on top.
They have no code changes apart from security fixes.
So if you don't want to change functionality, but you just want to fix the CVEs, these
would be the ones you go for.
And if we look back to the build numbers slide here, we can see that there are actually
three security releases, R1, R2, R3.
And they have weird build IDs as well, instead of following the BP, whatever convention.
They have some number, which I don't fully understand what the meaning of that number is.
And, oh yeah, final thing.
There has been changes over the last 12 months as to how often Google actually release
code to their public get servers.
So they use two push things on a regular basis to get, and you would see release numbers,
so underscore R and some number, incrementing up to into the 50s and 60s and 70s.
So there are a lot of releases.
They don't really do that anymore.
And in particular since the start of this year, there was a statement at source.android.com
that says that we will publish the source code to in QT and Q4, in other words, the major
release and the QPR2 release.
That's all you get these days.
Two code drops a year, nothing else.
Well, it's not quite true.
You still get the security updates every quarter, but remember, they don't contain functionality
changes, they are just CV fixes.
So this is where we are at.
I'm nearly finished.
The last slide, maybe I want to take a quick picture of this because it's only going
to be on the screen for a moment or two, some links.
The most important thing probably is feel free to meet us at Brudog this evening.
In the middle of the clock, you'll have to buy your own beer, I'm afraid, but we have
to get together and discuss all this further.
Okay, that's me, Don.
Thank you all very much.