libbinder & libutils

Foundation Libraries: libbinder, libutils, and libbase

Beneath the Android Framework lies a thick layer of C++ code responsible for system services, hardware abstraction, and inter-process communication. This layer relies heavily on several core AOSP libraries.

libbinder: Native Binder IPC

While app developers use AIDL and Java Binder interfaces, the actual communication mechanism is implemented in C++ within libbinder. This library interfaces directly with the Linux kernel's Binder driver (/dev/binder).

Native system services (like SurfaceFlinger or AudioFlinger) use libbinder to register themselves and accept cross-process calls.

ProcessState and IPCThreadState

Two singleton classes in libbinder manage the IPC lifecycle:

• ProcessState: Initializes the Binder driver for the process. It opens /dev/binder, maps memory using mmap, and manages the thread pool limits for incoming Binder calls.
• IPCThreadState: Manages the Binder state for a specific thread. It is responsible for actually reading from and writing to the Binder driver using the ioctl system call (specifically BINDER_WRITE_READ). It handles the transaction loops, blocking until a Binder message arrives.

// Typical initialization for a native AOSP daemon
int main() {
    // Initialize Binder for this process
    android::ProcessState::self()->startThreadPool();
    
    // Register local service
    android::defaultServiceManager()->addService(
        android::String16("my_native_service"), new MyNativeService());
        
    // Join the thread pool to handle incoming requests
    android::IPCThreadState::self()->joinThreadPool();
    return 0;
}

libutils: Core AOSP Utilities

libutils is a legacy, yet ubiquitous, utility library used throughout the AOSP C++ codebase. It provides fundamental data structures and concurrency primitives.

Reference Counting: RefBase and StrongPointer

AOSP C++ predates standard C++11 smart pointers (std::shared_ptr). Instead, it uses its own intrusive reference counting system.

• RefBase: A base class for objects that need reference counting. It contains the atomic counter.
• sp<T> (Strong Pointer): The AOSP equivalent of std::shared_ptr. It automatically increments the reference count on creation/copy and decrements it on destruction. When the count reaches zero, the object is deleted.
• wp<T> (Weak Pointer): A non-owning reference, similar to std::weak_ptr.

#include <utils/RefBase.h>
#include <utils/StrongPointer.h>

class MyObject : public android::RefBase {
public:
    void doSomething() {}
};

void example() {
    android::sp<MyObject> obj = new MyObject(); // Ref count is 1
    obj->doSomething();
    // obj goes out of scope, ref count drops to 0, memory is freed.
}

Concurrency: Mutex and Condition

libutils provides Mutex and Condition classes, which are wrappers around Bionic's pthread_mutex_t and pthread_cond_t. They provide an object-oriented way to handle thread synchronization in native code.

libbase: Modern Android Utilities

libbase is a newer library designed to supplement and eventually replace parts of libutils. It provides more modern, standard C++-like utilities tailored for Android.

Key features include:

• File I/O helpers (ReadFdToString, WriteStringToFile).
• String manipulation (Split, Join, StartsWith).
• Logging macros (LOG(INFO), CHECK(condition)).

libbase is heavily preferred for new AOSP development over the older libutils equivalents.