{"id":26,"date":"2023-06-28T11:15:00","date_gmt":"2023-06-28T11:15:00","guid":{"rendered":"https:\/\/embeddedbits.org\/?p=26"},"modified":"2024-03-02T09:45:32","modified_gmt":"2024-03-02T09:45:32","slug":"what-differs-android-from-other-linux-based-systems-embeddedbits","status":"publish","type":"post","link":"https:\/\/embeddedbits.org\/what-differs-android-from-other-linux-based-systems-embeddedbits\/","title":{"rendered":"What differs Android from other Linux based systems?"},"content":{"rendered":"

This article is an introduction to embedded Android from the perspective of an embedded Linux developer.<\/p>\n

If you are an embedded Linux developer but have never worked with embedded Android, this article is for you. If you develop or maintain Linux distros, and I want to start developing Android distros, this article is for you. If you are an Android application developer and want to understand a bit of how Android (internally) works, this article is also for you. And if you are just curious, this article is also for you! \ud83d\ude42<\/p>\n

We will compare a GNU\/Linux system with Android in different perspectives, from the build system to the partition layout, from the content of the rootfs to the architecture of the operating system components, from the IPC\/RPC mechanism to how hardware access works. I hope you have fun!<\/p>\n

Now, if you prefer a one hour talk instead of reading this article, you can also watch the talk \u201cWhat Differs the Android Open Source Project from Other Linux Distributions?\u201d presented at Embedded Linux Conference Europe 2020 (YouTube link<\/a>).<\/p>\n

Let\u2019s start with a high-level overview\u2026<\/p>\n

The difference in a nutshell<\/h2>\n

If you look at the architecture of any embedded Linux system, you will always find the same main components:<\/p>\n

    \n
  1. One or more bootloader(s) to bootstrap, configure the hardware and boot the Linux kernel.<\/li>\n
  2. The Linux kernel.<\/li>\n
  3. The root filesystem (rootfs) with the libraries and applications.<\/li>\n<\/ol>\n

    <\/p>\n

    Now, if you look at the same diagram for an Android-based system, what would be the differences?<\/p>\n

      \n
    1. The bootloader is there. Android doesn\u2019t require anything special in the bootloader, although it is common for people to add support to fastboot<\/a>, a protocol Google created for users and developers to interact with bootloaders on Android-based systems.<\/li>\n
    2. The Linux kernel is also there, but with a \u201cfew\u201d changes. More on that later.<\/li>\n
    3. The root filesystem is also there. But it is REALLY different! Nothing like a typical root filesystem from Debian or a custom-built rootfs from Buildroot or OpenEmbedded.<\/li>\n<\/ol>\n

      <\/p>\n

      As we can see from the image above, Android userspace components are clearly divided in three main layers:<\/p>\n

        \n
      1. Native: this is where all native (C\/C++) applications and libraries resides. It is called native because it runs outside the ART Virtual Machine. The native layer basically serves the purpose of abstracting Linux kernel interfaces to the framework layer.<\/li>\n
      2. Framework: this is where all operating system services are implemented (mostly in Java). Access to operating system resources are (remotely) exposed via components called system services, using an IPC\/RPC mechanism called Binder. And an API will abstract the access to those system services for the applications.<\/li>\n
      3. Application: Usually written in Java or Kotlin, they just see the exposed operating system API.<\/li>\n<\/ol>\n

        Before studying Android userspace components in details, let\u2019s talk a little bit about the kernel.<\/p>\n

        Linux kernel<\/h2>\n

        To run an Android-based system, we need a few extra \u201cfeatures\u201d enabled in the Linux kernel. This article would be too long if I would try to go over most features, but I can comment on some:<\/p>\n