Google is generally pretty good about keeping source compatibility, but ABIs change, and sometimes completely unrelated changes break everything for no obvious reason. Some things I've encountered include:
* sensor blobs crashing when using a clang-built libc, but working with a gcc-built one.
* blobs crashing when using jemalloc, but not dlmalloc (dlmalloc was removed with 7.0).
* Vendors introducing hacks in the OS - workarounds to deal with broken HW media encoders (which misinterpret pixel formats), misbehaving GL blobs, or devices which expect one pixel format for their display when the system provides another (e.g. RGB vs BGR).
* closed-source OpenGL drivers which use-after-free - the bug's probably existed since forever, but it only manifests after 7.0.
[1]: https://github.com/LineageOS/android_kernel_samsung_smdk4412...
That's why XDA is full of ROMs that "just need to get GPS working and camera sometimes crashes" :(
How come Google doesn't try to source better hardware for their phones? Also, is this the cause of why Apple in-housed a lot of things?
Also, how come there isn't an isolation layer for these blobs, something like docker for the phone? (So they get their runtime dependencies, and communicate with them via a socket-shim?)
Google should put some resources into kernel development for a year or so.Get the changes they want into Linux 5.0 and make it the android long-term-release kernel. Then no further changes to the kernel unless its 0.0.1 security patches.
Probably the only instance that I'm aware of where an OEM has actually mainlined support for their own mobile devices is Samsung with some of their Tizen reference devices - "trats"[2], "trats2"[3] (which is pretty much identical to the Galaxy S3), "tm2" and "tm2e"[4]. Of course, these will probably never gain support for certain things like 3D acceleration and the modem in mainline, but it's certainly a good start. (Note: a few Nexus devices seem to have mainline DTS[5], but I'm not sure how complete they are).
[1]: https://android.googlesource.com/kernel/common/ [2]: https://github.com/torvalds/linux/blob/master/arch/arm/boot/... [3]: https://github.com/torvalds/linux/blob/master/arch/arm/boot/... [4]: https://github.com/torvalds/linux/tree/master/arch/arm64/boo... [5]: https://github.com/torvalds/linux/tree/master/arch/arm64/boo...
It doesn't have to be a mainstream kernel. The only important part is that it is a fixed kernel version so drivers and such does not need to be re-written with each new android release.
This is how it is done already. Google picks a kernel release (historically 3.0, 3.4, 3.10, 3.18, 4.4 etc.) and ports Android patches to that kernel while developing new features as well. Then SoC vendors do their bringups using that kernel tree.
A device is released with a specific kernel version and it doesn't get upgraded in devices lifetime even if the same device gets several Android upgrades. Native Nougat devices released in 2017 have kernel 4.4 which was released in early 2016, which is not even considered a new kernel by the upstream standards.
What do you expect the benefit everyone gains from sticking to the same kernel for 5 years? What is the point of developing a SoC in 2017 and bringing it up using Linux 2.6.32 instead of Linux 4.4? What is the benefit for Quallcomm, for Google or for users?
I don't understand the problems with backward compatibility. They already provide it via the Android SDK (the support library).
Java/Dex/Dalvik/ART or whatever it's called now that runs the shit works on Linux 3.0 probably. (Android 2.3 was released with Linux 2.6.35 [+ patches, I assume && hope], and that's currently the lowest supported API Level (that is api level 9)).