Fundamental concepts that power the Android ecosystem

Hello everyone, welcome back again! In today's article, we're delving into some fundamental concepts that power the Android ecosystem.

We'll cover topics:

• Understanding the Zygote Process: How Apps Start on Android?
• Understanding Garbage Collection in Java
• What is ART – Modern Android Runtime?
• Decoding ANDROID JIT (Just-In-Time Compilation)
• Dalvik Virtual Machine (DVM)

Get ready to unravel these essential building blocks of the Android world!

Let's jump right in without any delay and break down each of these concepts.

Understanding the Zygote Process: How Apps Start on Android?

As the Android Operating System comes to life, a crucial player enters the stage – the Zygote process. This process is like a guardian that waits for new app launch requests. Whenever you tap on an app icon, Zygote takes the lead in getting it up and running. Imagine it as the app-launching maestro.

Zygote employs a clever trick. When it's time to launch a new app, it makes a copy of itself using a technique known as a fork system call. This duplication process happens lightning-fast, ensuring quick app launches. This approach also makes things efficient since the new app process shares resources with the parent Zygote.

Now, picture this: the freshly initiated app process is like a canvas being prepared for a masterpiece. It loads up all the essential code required to bring the app to life. And remember those classes.dex files we talked about earlier? They contain the app's bytecode that's compatible with the Dalvik Virtual Machine.

But wait, there's more! In Android devices from version 5.0 onwards, things get even smarter. The default runtime environment becomes ART (Android Runtime). Here, are the classes.dex file undergoes a transformation. It's converted into something called OAT using a tool named dex2oat. This clever conversion optimizes performance and helps your app run smoothly.

So, the next time you tap on an app and it swiftly appears on your screen, you'll know that the Zygote process played a crucial role in making it happen!

 

Understanding Garbage Collection in Java

Now, let’s understand the Garbage Collection in Java.

In Java, an automatic garbage collection mechanism is employed to manage memory. This mechanism is responsible for reclaiming memory that is no longer needed within a managed memory environment.

The primary objectives of garbage collection are twofold: firstly, to identify data objects in a program that are no longer accessible in the future, and secondly, to free up the resources occupied by these objects. Objects can belong to different generations, such as active, younger, older, and permanent generations. The time taken by the garbage collector varies depending on the generation to which an object belongs.

Comparing this to manual garbage collection, where it's the user or programmer's responsibility to release memory, automatic garbage collection offers both advantages and disadvantages. On the positive side, it enhances performance by efficiently freeing up memory. However, since it operates automatically, the timing of memory reclamation is beyond the user's control. For instance, if the collector initiates its task during a critical operation, it might impact performance negatively.

 

What is ART – Modern Android Runtime?

Let's delve into the world of ART - the new Android Runtime. ART was first introduced in Android 4.4 as an optional runtime environment, allowing users to choose it from developer options on their devices. Starting from Android 5.0 (Lollipop), Google made ART the default runtime.

ART operates by transforming an application's bytecode into native machine code during installation on the user's device. This process is known as ahead-of-time compilation. 

In contrast, before ART's introduction, Dalvik used to convert bytecode to native code at runtime, in what's called the JIT (Just-in-Time) approach. The noteworthy advantage of ART lies in its approach to bytecode conversion. 

Unlike the JIT approach, ART doesn't need to convert bytecode into machine code every time the app launches; this is already accomplished during the app's installation. 

Although this might result in a slight delay during the first run, it leads to substantial performance enhancements and improved battery life in subsequent runs.

Decoding ANDROID JIT (Just-In-Time Compilation)

Within the Android runtime (ART), a just-in-time (JIT) compiler plays a pivotal role by continually enhancing the performance of Android applications during their execution.

Here's how the JIT compilation process unfolds: 

When a user initiates an app, ART internally loads the .dex file. If a .oat file (the Ahead-Of-Time binary for the .dex file ) is available, ART directly employs it. 

However, these .oat files, which contain pre-compiled AOT binary code, may not always be present. In such cases, ART resorts to JIT compilation, along with an interpreter, to execute the .dex file.

The JIT profile data, accumulated during app usage, gets stored in a system directory accessible only to the application. This profile data guides the AOT compilation (performed by the dex2oat daemon) in parsing and driving the compilation process.

In essence, the Android JIT mechanism dynamically optimizes the execution of apps through on-the-fly compilation, refining performance and responsiveness.

 

Dalvik Virtual Machine (DVM)

A Virtual Machine (VM) is a simulated computer system that mimics the functions of a real computer. It's crafted using the physical components such as the hard disk, CPU, RAM, and other resources available on the host machine. Through virtualization, you can set up multiple guest operating systems on a single host operating system. Hypervisors, commonly used, help in creating VMs either through full virtualization or para-virtualization methods.

Typically, standard Java applications follow a common procedure for executing Java programs. First, the source code file with the ".java" extension is compiled, resulting in the creation of intermediate code known as bytecode. This bytecode is saved with a " .class " extension. To execute this code, Java interpreter tools come into play.

However, in the modern context, the Java Virtual Machine (JVM) is designed for high performance and boasts efficient memory management. Nonetheless, there's a need to tailor it for low-powered handheld devices too. Consequently, it's re-engineered to accommodate mobile devices and their applications.

When bytecode is executed using the Java Interpreter and JVM, a pivotal role is assumed by the Just-in-time (JIT) compiler. This compiler translates bytecode into machine code. In contrast to languages like C or C++, which involve creating multiple .obj files and linking them with a linker, Java simplifies this process by omitting the linking step.

Tailored specifically for Android, the  Dalvik Virtual Machine (DVM)  emerges as a specialized VM optimized for mobile devices. It places emphasis on memory efficiency, battery life, and overall performance. Interestingly, the moniker " Dalvik " takes inspiration from a town in Iceland. The visionary responsible for shaping the Dalvik VM is  Dan Bornstein.

Within the Android ecosystem, the Dex compiler handles the conversion of class files into .dex files, compatible with the Dalvik VM. It's notable that a multitude of class files consolidate into a single dex file, streamlining the workflow.

Throughout the compilation journey of the Dalvik VM, optimization is at the forefront. The focus lies on enhancing app performance, efficiency, and overall functionality, contributing to a more seamless user experience.

In the realm of the Android platform, the Dalvik VM assumes its role. It operates as an interpreter-only VM, executing files in the Dalvik Executable (.dex) format. This format is designed for efficient storage and memory-mappable execution. Operating on a register-based structure, it can handle classes transformed by a Java language compiler, converted into its native format using the " d8 " tool. 

The VM functions atop POSIX-compliant OSs, relying on them for underlying functionality such as threading and low-level memory management. The Dalvik core class library aims to provide a familiar development foundation for those accustomed to programming with Java Standard Edition. However, it is tailored specifically to meet the requirements of small mobile devices. 

In this article, we have covered the fundamental concepts that underpin the Android ecosystem. In our next article, we delve into understanding Android app sandboxing. 

Understanding App Sandboxing

This article explores the concept of app sandboxing, a crucial aspect of modern application security. Understanding how app sandboxing works is essential for developers and security professionals to ensure the safety and security of mobile and desktop applications.

If there are any queries, then write them in my comment section.