Binder

https://github.com/androidgolab/binder
Admin
Binder is a pure Go library for calling Android system services directly via the Binder IPC...
Tokens:14,137
Snippets:212
Trust Score:7.5
License:CC0-1.0
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install Binder MCP via go install

Source: https://github.com/androidgolab/binder/blob/main/README.md

Install the binder-mcp command-line tool globally using `go install`. This is a convenient way to get the latest version.

```bash
go install github.com/AndroidGoLab/binder/cmd/binder-mcp@latest
```

--------------------------------

### Pure Go ADB Session Proxy Example

Source: https://github.com/androidgolab/binder/blob/main/README.md

Example of setting up a forwarded ADB session using the `proxy` package from `interop/gadb`. This manages the daemon lifecycle and port forwarding for binder calls.

```go
sess, _ := proxy.NewSession(ctx, "SERIAL")
defer sess.Close(ctx)
// Session manages the daemon lifecycle and port forwarding;
// binder calls are routed through the remote transport.
```

--------------------------------

### List All Installed Packages

Source: https://github.com/androidgolab/binder/blob/main/README.md

Retrieves and lists all installed packages on the device. Requires access to the PackageService via the service manager.

```go
import (
    "github.com/AndroidGoLab/binder/android/content/pm"
    "github.com/AndroidGoLab/binder/servicemanager"
)

    svc, err := sm.GetService(ctx, servicemanager.PackageService)
    if err != nil {
        log.Fatal(err)
    }
    pkgMgr := pm.NewPackageManagerProxy(svc)

    packages, err := pkgMgr.GetAllPackages(ctx)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Found %d packages:\n", len(packages))
    for _, pkg := range packages {
        fmt.Println(" ", pkg)
    }
```

--------------------------------

### Pure Go ADB Device Runner Example

Source: https://github.com/androidgolab/binder/blob/main/README.md

Example of using the `runner` package from `interop/gadb` to control ADB devices programmatically in Go. It demonstrates discovering devices, pushing binaries, and running commands.

```go
dr, _ := runner.NewDeviceRunner("SERIAL")
dr.PushBinary(ctx, "build/mybinary", "/data/local/tmp/mybinary")
result, _ := dr.Run(ctx, "/data/local/tmp/mybinary", 30*time.Second)
fmt.Println(result.Stdout)
```

--------------------------------

### Check Package Installation

Source: https://github.com/androidgolab/binder/blob/main/README.md

Verify if a specific application package is installed on the device for a given user ID.

```bash
bindercli android.content.pm.IPackageManager is-package-available \
  --packageName com.android.settings --userId 0
```

--------------------------------

### Install and Deploy bindercli

Source: https://github.com/androidgolab/binder/blob/main/README.md

Build the bindercli binary for Linux ARM64 and push it to the device's temporary directory.

```bash
GOOS=linux GOARCH=arm64 go build -o build/bindercli ./cmd/bindercli/
adb push build/bindercli /data/local/tmp/
```

--------------------------------

### Get Package Installer

Source: https://github.com/androidgolab/binder/blob/main/README.md

Retrieve the package name of the application that installed a specified package.

```bash
bindercli android.content.pm.IPackageManager get-installer-package-name \
  --packageName com.android.chrome
```

--------------------------------

### Get GPS hardware info

Source: https://github.com/androidgolab/binder/blob/main/README.md

Use bindercli to query the LocationManager service for the GPS hardware model name.

```bash
adb shell /data/local/tmp/bindercli android.location.ILocationManager get-gnss-hardware-model-name
```

--------------------------------

### Get Camera Characteristics

Source: https://github.com/androidgolab/binder/blob/main/README.md

Retrieve the characteristics of a camera device, such as its capabilities and supported resolutions.

```bash
bindercli android.hardware.camera.device.ICameraDevice get-camera-characteristics
```

--------------------------------

### Check battery level using bindercli

Source: https://github.com/androidgolab/binder/blob/main/README.md

Query the Health service to get battery information.

```bash
adb shell /data/local/tmp/bindercli android.hardware.health.IHealth get-health-info
```

--------------------------------

### Get Process Memory Limit

Source: https://github.com/androidgolab/binder/blob/main/README.md

Retrieve the memory limit configured for processes on the system.

```bash
bindercli android.app.IActivityManager get-process-limit
```

--------------------------------

### AIDL Interface Definition

Source: https://github.com/androidgolab/binder/blob/main/README.md

An example of an AIDL interface definition for IActivityManager, outlining methods and their signatures.

```java
// android/app/IActivityManager.aidl
package android.app;

interface IActivityManager {
    int getProcessLimit();
    int checkPermission(in String permission, int pid, int uid);
    boolean isUserAMonkey();
    // ... 200+ more methods
}
```

--------------------------------

### Connect to a Vibrator Service

Source: https://github.com/androidgolab/binder/blob/main/README.md

Obtain a service manager and get the proxy for the IVibrator AIDL interface. This is useful for interacting with hardware features like vibration.

```go
svc, err := sm.GetService(ctx, servicemanager.ServiceName(
        vibrator.DescriptorIVibrator+"/default"))
    if err != nil {
        log.Fatal(err)
    }
    proxy := vibrator.NewVibratorProxy(svc)
    caps, err := proxy.GetCapabilities(ctx)
```

--------------------------------

### Get Display IDs

Source: https://github.com/androidgolab/binder/blob/main/README.md

Retrieve a list of display IDs, with an option to include disabled displays.

```bash
bindercli android.hardware.display.IDisplayManager get-display-ids \
  --includeDisabled false
```

--------------------------------

### Get Active Microphones

Source: https://github.com/androidgolab/binder/blob/main/README.md

Retrieve a list of microphones that are currently active on an input audio stream.

```bash
bindercli android.hardware.audio.core.IStreamIn get-active-microphones
```

--------------------------------

### Get Network Country ISO

Source: https://github.com/androidgolab/binder/blob/main/README.md

Use this command to retrieve the network country ISO for a specific phone ID.

```bash
bindercli com.android.internal.telephony.ITelephony get-network-country-iso-for-phone \
  --phoneId 0
```

--------------------------------

### Get GPS Location

Source: https://github.com/androidgolab/binder/blob/main/README.md

Retrieves the last known GPS location. Requires the kernel binder driver to be open and a transport to be established.

```go
import (
    "context"
    "fmt"
    "log"

    "github.com/AndroidGoLab/binder/android/location"
    "github.com/AndroidGoLab/binder/binder"
    "github.com/AndroidGoLab/binder/binder/versionaware"
    "github.com/AndroidGoLab/binder/kernelbinder"
    "github.com/AndroidGoLab/binder/servicemanager"
)

    ctx := context.Background()

    driver, err := kernelbinder.Open(ctx, binder.WithMapSize(128*1024))
    if err != nil {
        log.Fatal(err)
    }
    defer driver.Close(ctx)

    transport, err := versionaware.NewTransport(ctx, driver, 0)
    if err != nil {
        log.Fatal(err)
    }
    sm := servicemanager.New(transport)

    lm, err := location.GetLocationManager(ctx, sm)
    if err != nil {
        log.Fatal(err)
    }

    loc, err := lm.GetLastLocation(ctx, location.FusedProvider, location.LastLocationRequest{}, binder.DefaultCallerIdentity().PackageName)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Lat: %f, Lon: %f, Alt: %f\n",
        loc.LatitudeDegrees, loc.LongitudeDegrees, loc.AltitudeMeters)
    fmt.Printf("Speed: %f m/s, Bearing: %f°\n",
        loc.SpeedMetersPerSecond, loc.BearingDegrees)
```

--------------------------------

### Get Live GPS Location via Binder IPC

Source: https://github.com/androidgolab/binder/blob/main/README.md

This snippet demonstrates how to register a listener to receive live GPS location updates from the Android LocationManager. Ensure you have the necessary permissions and that the GPS provider is enabled.

```go
package main

import (
    "context"
    "fmt"
    "math"
    "os"
    "time"

    "github.com/AndroidGoLab/binder/android/location"
    androidos "github.com/AndroidGoLab/binder/android/os"
    "github.com/AndroidGoLab/binder/binder"
    "github.com/AndroidGoLab/binder/binder/versionaware"
    "github.com/AndroidGoLab/binder/kernelbinder"
    "github.com/AndroidGoLab/binder/servicemanager"
)

// gpsListener receives location callbacks from the LocationManager.
type gpsListener struct{ fixCh chan location.Location }

func (l *gpsListener) OnLocationChanged(_ context.Context, locs []location.Location, _ androidos.IRemoteCallback) error {
    for _, loc := range locs { select { case l.fixCh <- loc: default: } }
    return nil
}
func (l *gpsListener) OnProviderEnabledChanged(_ context.Context, _ string, _ bool) error { return nil }
func (l *gpsListener) OnFlushComplete(_ context.Context, _ int32) error                   { return nil }

func main() {
    ctx := context.Background()
    drv, _ := kernelbinder.Open(ctx, binder.WithMapSize(128*1024))
    defer drv.Close(ctx)
    transport, _ := versionaware.NewTransport(ctx, drv, 0)
    sm := servicemanager.New(transport)

    lm, _ := location.GetLocationManager(ctx, sm)

    impl := &gpsListener{fixCh: make(chan location.Location, 1)}
    listener := location.NewLocationListenerStub(impl)

    request := location.LocationRequest{
        Provider: location.GpsProvider, IntervalMillis: 1000,
        ExpireAtRealtimeMillis: math.MaxInt64, DurationMillis: math.MaxInt64,
    }
    pkg := binder.DefaultCallerIdentity().PackageName
    _ = lm.RegisterLocationListener(ctx, location.GpsProvider, request, listener, pkg, "gps")
    defer lm.UnregisterLocationListener(ctx, listener)

    select {
    case loc := <-impl.fixCh:
        fmt.Printf("Lat: %.6f  Lon: %.6f  Alt: %.1f m  Accuracy: %.1f m\n",
            loc.LatitudeDegrees, loc.LongitudeDegrees, loc.AltitudeMeters, loc.HorizontalAccuracyMeters)
    case <-time.After(30 * time.Second):
        fmt.Fprintln(os.Stderr, "timed out")
    }
}
```

--------------------------------

### Get Active Phone Type

Source: https://github.com/androidgolab/binder/blob/main/README.md

Retrieve the active phone type, indicating the cellular technology in use (e.g., GSM, CDMA).

```bash
bindercli com.android.internal.telephony.ITelephony get-active-phone-type
```

--------------------------------

### Query Power and Battery State

Source: https://github.com/androidgolab/binder/blob/main/README.md

Interact with the IPowerManager and IHealth services to check device power states and battery information. Examples include checking screen status, power save mode, doze mode, and retrieving battery health.

```bash
# Check if screen is on
bindercli android.os.IPowerManager is-interactive
# Example output: {"result":true}
```

```bash
# Check power save mode
bindercli android.os.IPowerManager is-power-save-mode
# Example output: {"result":false}
```

```bash
# Check if device is in Doze mode
bindercli android.os.IPowerManager is-device-idle-mode
# Example output: {"result":false}
```

```bash
# Get battery health info
bindercli android.hardware.health.IHealth get-health-info
```

--------------------------------

### Query Thermal Status

Source: https://github.com/androidgolab/binder/blob/main/README.md

Get the current thermal status of the device. Status values range from 0 (none) to higher levels indicating increasing heat.

```bash
bindercli android.os.IThermalService get-current-thermal-status
```

--------------------------------

### Configure Wi-Fi Network

Source: https://github.com/androidgolab/binder/blob/main/README.md

Set key management to WPA-PSK and enable the network for connection.

```bash
bindercli android.hardware.wifi.supplicant.ISupplicantStaNetwork set-key-mgmt \
  --keyMgmtMask 2
```

```bash
bindercli android.hardware.wifi.supplicant.ISupplicantStaNetwork enable \
  --noConnect false
```

--------------------------------

### List and Inspect Binder Services

Source: https://github.com/androidgolab/binder/blob/main/README.md

Commands to manage and query binder services. Use 'list' to see all services, 'inspect' for details on a specific service, 'methods' to see its functions, 'resolve' to map methods to transaction codes, and 'transact' to send raw transactions.

```bash
# List all registered binder services with alive/dead status
bindercli service list
```

```bash
# Inspect a specific service (show handle, descriptor, alive status)
bindercli service inspect SurfaceFlinger
```

```bash
# List methods available on a service with transaction codes
bindercli service methods activity
```

```bash
# Resolve a method name to its transaction code (or vice versa)
bindercli service resolve activity is-user-a-monkey
```

```bash
# Send a raw binder transaction by method name or numeric code
bindercli service transact activity is-user-a-monkey
bindercli service transact SurfaceFlinger 64
```

--------------------------------

### Connect to a HAL Service

Source: https://github.com/androidgolab/binder/blob/main/README.md

Connect to a Hardware Abstraction Layer (HAL) service by appending "/default" to its AIDL descriptor. This is a common pattern for interacting with hardware components.

```go
svc, err := sm.GetService(ctx, servicemanager.ServiceName(health.DescriptorIHealth+"/default"))
```

--------------------------------

### List all binder services

Source: https://github.com/androidgolab/binder/blob/main/README.md

Use bindercli to list all available binder services on the Android device.

```bash
adb shell /data/local/tmp/bindercli service list
```

--------------------------------

### Initialize Bluetooth HCI

Source: https://github.com/androidgolab/binder/blob/main/README.md

Initialize the Bluetooth Host Controller Interface (HCI) with a specified callback service.

```bash
bindercli android.hardware.bluetooth.IBluetoothHci initialize \
  --callback <callback_service>
```

--------------------------------

### Implement and Register a Server-Side Service

Source: https://github.com/androidgolab/binder/blob/main/README.md

Define a service that implements the binder.TransactionReceiver interface and register it with the ServiceManager. This allows other clients to connect to your service.

```go
import (
    "context"

    "github.com/AndroidGoLab/binder/binder"
    "github.com/AndroidGoLab/binder/parcel"
    "github.com/AndroidGoLab/binder/servicemanager"
)

// myService implements binder.TransactionReceiver for a simple ping service.
type myService struct{}

func (s *myService) Descriptor() string { return "com.example.IPingService" }

func (s *myService) OnTransaction(
    ctx context.Context,
    code binder.TransactionCode,
    data *parcel.Parcel,
) (*parcel.Parcel, error) {
    reply := parcel.New()
    binder.WriteStatus(reply, nil)
    reply.WriteString16("pong")
    return reply, nil
}
```

```go
    // Register with ServiceManager
    err := sm.AddService(ctx, servicemanager.ServiceName("my.service"), &myService{}, false, 0)
```

--------------------------------

### Run Binder MCP in Remote Mode

Source: https://github.com/androidgolab/binder/blob/main/README.md

Execute the binder-mcp in remote mode using `go run`. It automatically discovers devices via ADB, pushes the daemon, and serves MCP over stdio.

```bash
go run ./cmd/binder-mcp/ --mode remote
```

--------------------------------

### Run Binder MCP via Docker

Source: https://github.com/androidgolab/binder/blob/main/README.md

Use the binder-mcp tool by running its Docker image. This is suitable for host mode operations.

```bash
docker run ghcr.io/androidgolab/binder-mcp
```

--------------------------------

### Configure Microphone Settings

Source: https://github.com/androidgolab/binder/blob/main/README.md

Set the field dimension (zoom) and direction for directional audio recording.

```bash
bindercli android.hardware.audio.core.IStreamIn set-microphone-field-dimension \
  --zoom 1.0
```

```bash
bindercli android.hardware.audio.core.IStreamIn set-microphone-direction \
  --direction 1
```

--------------------------------

### Build and Push Binder MCP for Android

Source: https://github.com/androidgolab/binder/blob/main/README.md

Build the binder-mcp binary for Linux ARM64 and push it to the Android device via ADB. This is for on-device usage.

```bash
GOOS=linux GOARCH=arm64 CGO_ENABLED=0 go build -o build/binder-mcp ./cmd/binder-mcp/
adb push build/binder-mcp /data/local/tmp/
```

--------------------------------

### Bulk Generation from AOSP

Source: https://github.com/androidgolab/binder/blob/main/README.md

Commands to generate Go proxies for all AOSP services by first updating submodules, then running AIDL to spec conversion and spec to Go conversion.

```bash
git submodule update --init --depth 1
go run ./tools/cmd/aidl2spec -3rdparty tools/pkg/3rdparty -output specs/
go run ./tools/cmd/spec2go -specs specs/ -output . -smoke-tests
```

--------------------------------

### Compile AIDL Files to Go

Source: https://github.com/androidgolab/binder/blob/main/README.md

Command to compile AIDL files into Go code using the bindercli tool. Specify input directories and output files.

```bash
# Compile AIDL files to Go via bindercli:
bindercli aidl compile -I path/to/search/root --output gen file1.aidl file2.aidl
```

--------------------------------

### Query ActivityManager for process limit

Source: https://github.com/androidgolab/binder/blob/main/README.md

Use bindercli to query the ActivityManager service for the process limit.

```bash
adb shell /data/local/tmp/bindercli android.app.IActivityManager get-process-limit
```

--------------------------------

### Check App Freezer Support

Source: https://github.com/androidgolab/binder/blob/main/README.md

Determine if the device's app freezer functionality is supported.

```bash
bindercli android.app.IActivityManager is-app-freezer-supported
```

--------------------------------

### List Binder Services

Source: https://github.com/androidgolab/binder/blob/main/README.md

Lists all active binder services available on the system. Assumes a service manager and transport are already set up.

```go
    sm := servicemanager.New(transport)

    services, err := sm.ListServices(ctx)
    if err != nil {
        log.Fatal(err)
    }

    for _, name := range services {
        svc, err := sm.CheckService(ctx, name)
        if err == nil && svc != nil && svc.IsAlive(ctx) {
            fmt.Printf("% -60s alive\n", name)
        }
    }
```

--------------------------------

### Build and Push Binder MCP for On-Device ADB

Source: https://github.com/androidgolab/binder/blob/main/README.md

Build the binder-mcp binary for Android and push it to the device via ADB. This is for running binder-mcp directly on the Android device.

```bash
# Build for Android
GOOS=linux GOARCH=arm64 CGO_ENABLED=0 go build -o binder-mcp ./cmd/binder-mcp/
 הראש
adb push binder-mcp /data/local/tmp/
```

--------------------------------

### List Camera Devices

Source: https://github.com/androidgolab/binder/blob/main/README.md

Retrieve a list of available camera device IDs.

```bash
bindercli android.hardware.camera.provider.ICameraProvider get-camera-id-list
```

--------------------------------

### Toggle Flashlight (Control)

Source: https://github.com/androidgolab/binder/blob/main/README.md

Turns the flashlight on and off using the CameraService. Requires a client token and assumes the service manager and transport are set up.

```go
    svc, err := sm.GetService(ctx, servicemanager.MediaCameraService)
    if err != nil {
        log.Fatal(err)
    }
    camera := hardware.NewCameraServiceProxy(svc)

    // The camera service requires a non-null client binder token.
    clientToken := binder.NewStubBinder(&torchToken{})
    clientToken.RegisterWithTransport(ctx, transport)

    // Turn torch on for camera "0"
    if err := camera.SetTorchMode(ctx, "0", true, clientToken); err != nil {
        log.Fatal(err)
    }
    fmt.Println("Torch ON")

    // Turn torch off
    _ = camera.SetTorchMode(ctx, "0", false, clientToken)
```

--------------------------------

### Binder Runtime Flow

Source: https://github.com/androidgolab/binder/blob/main/README.md

Illustrates the flow of an IPC transaction using the Binder runtime. It shows the interaction between the application proxy, parcel marshaling, binder transactions, and the kernel binder driver.

```mermaid
flowchart TD
    subgraph APP["Your Go Application"]
        PROXY2["ActivityManagerProxy.GetProcessLimit(ctx)"]
    end

    subgraph MARSHAL["parcel"]
        M1["WriteInterfaceToken(descriptor)"]
        M2["WriteInt32 / WriteString16 / ..."]
        M3["ReadInt32 / ReadString16 / ..."]
    end

    subgraph BINDER["binder"]
        B1["IBinder.Transact(ctx, code, flags, data)"]
        B2["ReadStatus(reply) → check AIDL exceptions"]
    end

    subgraph KERNEL["kernelbinder"]
        K1["open(/dev/binder)"]
        K2["mmap(1MB read buffer)"]
        K3["ioctl(BINDER_WRITE_READ)"]
    end

    PROXY2 --> M1
    M1 --> M2
    M2 --> B1
    B1 --> K3
    K3 -->|reply| B2
    B2 --> M3
    M3 -->|typed result| PROXY2
```

--------------------------------

### Generate Smoke Tests and Run End-to-End Tests

Source: https://github.com/androidgolab/binder/blob/main/README.md

Generate smoke tests by running the spec2go command. Then, execute end-to-end tests on Android devices or emulators, requiring /dev/binder or mock mode.

```bash
go run ./tools/cmd/spec2go -specs specs/ -output . -smoke-tests
```

```bash
go test ./tests/e2e/...  # requires /dev/binder OR mock mode
```

--------------------------------

### Binder MCP Device Mode

Source: https://github.com/androidgolab/binder/blob/main/README.md

Initiate the binder-mcp tool in device mode. This tool allows AI agents to interact with Android devices by exposing binder services as tools.

```bash
```bash
```

--------------------------------

### Run End-to-End Tests on Android

Source: https://github.com/androidgolab/binder/blob/main/README.md

Execute full integration tests on an Android device or emulator. These tests interact with real Android system services via /dev/binder.

```bash
# Run on Android device or emulator
go test -tags e2e -v ./tests/e2e/...
```

--------------------------------

### Configure Cursor for Binder MCP

Source: https://github.com/androidgolab/binder/blob/main/README.md

Add binder-mcp configuration to Cursor's `.cursor/mcp.json` file. This allows Cursor to use binder-mcp for remote operations.

```json
{
  "mcpServers": {
    "binder-mcp": {
      "command": "binder-mcp",
      "args": ["--mode", "remote"]
    }
  }
}
```

--------------------------------

### Connect to WiFi AP

Source: https://github.com/androidgolab/binder/blob/main/README.md

Connect to a WiFi Access Point using the supplicant interface. This involves adding a network, setting its SSID and passphrase, and then enabling it.

```bash
# Step 1: Add a new network via the supplicant
bindercli android.hardware.wifi.supplicant.ISupplicantStaIface add-network
```

```bash
# Step 2: Set the SSID (pass as hex-encoded bytes; "MyNetwork" = 4d794e6574776f726b)
bindercli android.hardware.wifi.supplicant.ISupplicantStaNetwork set-ssid \
  --ssid 4d794e6574776f726b
```

```bash
# Step 3: Set the WPA passphrase
bindercli android.hardware.wifi.supplicant.ISupplicantStaNetwork set-psk-passphrase \
  --psk secret123
```

--------------------------------

### Build AAR with gomobile

Source: https://github.com/androidgolab/binder/blob/main/README.md

Command to build an Android AAR (Android Archive) file using `gomobile bind`. This AAR wraps binder calls in a Java-friendly API.

```bash
gomobile bind -target android -o binder.aar ./interop/gomobile/client/
```

--------------------------------

### Run Unit Tests

Source: https://github.com/androidgolab/binder/blob/main/README.md

Execute unit tests for parser, codegen, resolver, binder, parcel, typesys, and testutil packages. These tests run without an Android device or special environment.

```bash
go test ./tools/pkg/... ./binder/ ./parcel/
```

--------------------------------

### Configure Cline for Binder MCP

Source: https://github.com/androidgolab/binder/blob/main/README.md

Add binder-mcp configuration to Cline's MCP settings, including specific `alwaysAllow` permissions. This customizes binder-mcp usage within Cline.

```json
{
  "mcpServers": {
    "binder-mcp": {
      "command": "binder-mcp",
      "args": ["--mode", "remote"],
      "alwaysAllow": ["list_services", "get_device_info", "take_screenshot"]
    }
  }
}
```

--------------------------------

### Reboot Device

Source: https://github.com/androidgolab/binder/blob/main/README.md

Reboot the device with specified options for confirmation, reason, and wait behavior.

```bash
bindercli android.os.IPowerManager reboot \
  --confirm false --reason "cli-reboot" --wait true
```

--------------------------------

### Manage Wi-Fi Connections

Source: https://github.com/androidgolab/binder/blob/main/README.md

Disconnect from the current network and list saved networks.

```bash
bindercli android.hardware.wifi.supplicant.ISupplicantStaIface disconnect
```

```bash
bindercli android.hardware.wifi.supplicant.ISupplicantStaIface list-networks
```

--------------------------------

### AIDL Compiler Pipeline Stages

Source: https://github.com/androidgolab/binder/blob/main/README.md

The compiler transforms AIDL source files into Go code through four stages: Lexer, Parser, Resolver, and Code Generator. The Lexer tokenizes input, the Parser builds an AST, the Resolver handles imports and type checking, and the Code Generator produces Go source files.

```mermaid
flowchart LR
    subgraph S1["1. Lex"]
        L1["Keywords, identifiers,<br/>operators, literals"]
    end

    subgraph S2["2. Parse"]
        P1["Document AST:<br/>interfaces, parcelables,<br/>enums, unions, constants"]
    end

    subgraph S3["3. Resolve"]
        R1["Transitive imports<br/>Type registry<br/>Circular import detection"]
    end

    subgraph S4["4. Generate"]
        G1["Go source files:<br/>proxies, structs,<br/>marshal/unmarshal"]
    end

    S1 --> S2 --> S3 --> S4
```

--------------------------------

### Configure Agent for On-Device ADB Transport

Source: https://github.com/androidgolab/binder/blob/main/README.md

Configure an agent (e.g., Claude Code) to use the ADB transport for binder-mcp. This connects the agent to the binder-mcp running on the device.

```bash
claude mcp add --transport stdio binder-mcp -- adb shell /data/local/tmp/binder-mcp
```

--------------------------------

### Run AOSP Codegen Test

Source: https://github.com/androidgolab/binder/blob/main/README.md

Test code generation for the entire AOSP AIDL surface. This requires submodule initialization in tools/pkg/3rdparty. It parses all AIDL files, generates Go code, and verifies the output.

```bash
go test -tags aosp_codegen -v -run TestCodegenAllAOSP ./tools/pkg/codegen/
```

--------------------------------

### Toggle Flashlight

Source: https://github.com/androidgolab/binder/blob/main/README.md

Controls the device's flashlight using the CameraService. Requires CAMERA permission and a client token for the service. This snippet defines the client token structure.

```go
import (
    "context"

    "github.com/AndroidGoLab/binder/android/hardware"
    "github.com/AndroidGoLab/binder/binder"
    "github.com/AndroidGoLab/binder/parcel"
    "github.com/AndroidGoLab/binder/servicemanager"
)

// torchToken is a minimal TransactionReceiver for SetTorchMode's client binder.
type torchToken struct{}

func (t *torchToken) Descriptor() string { return "torch.client" }

func (t *torchToken) OnTransaction(
    _ context.Context,
    _ binder.TransactionCode,
    _ *parcel.Parcel,
) (*parcel.Parcel, error) {
    return parcel.New(), nil
}
```

--------------------------------

### Call System Service (ActivityManager)

Source: https://github.com/androidgolab/binder/blob/main/README.md

Interacts with the ActivityManager service to retrieve process limits and check if the user is a 'monkey' (automated test). Assumes a service manager and transport are set up.

```go
import (
    "github.com/AndroidGoLab/binder/android/app"
    "github.com/AndroidGoLab/binder/servicemanager"
)

    svc, err := sm.GetService(ctx, servicemanager.ActivityService)
    if err != nil {
        log.Fatal(err)
    }
    am := app.NewActivityManagerProxy(svc)

    limit, _ := am.GetProcessLimit(ctx)
    fmt.Printf("Process limit: %d\n", limit)

    monkey, _ := am.IsUserAMonkey(ctx)
    fmt.Printf("Is monkey: %v\n", monkey)
```

--------------------------------

### Check Process Permission

Source: https://github.com/androidgolab/binder/blob/main/README.md

Verify if a specific process (identified by PID and UID) holds a given permission.

```bash
bindercli android.app.IActivityManager check-permission 
  --permission android.permission.INTERNET --pid 1 --uid 0
```

--------------------------------

### Control Camera Flashlight

Source: https://github.com/androidgolab/binder/blob/main/README.md

Enable or disable the flashlight (torch) mode for a specified camera device.

```bash
bindercli android.hardware.camera.provider.ICameraProvider set-torch-mode \
  --cameraDeviceName "0" --enabled true
```

--------------------------------

### Check Device Interactivity

Source: https://github.com/androidgolab/binder/blob/main/README.md

Check if the device is currently interactive, which typically means the screen is on.

```bash
bindercli android.os.IPowerManager is-interactive
```

--------------------------------

### Force Stop Package

Source: https://github.com/androidgolab/binder/blob/main/README.md

Forcefully stop a running application package for a specified user.

```bash
bindercli android.app.IActivityManager force-stop-package 
  --packageName com.example.app --userId 0
```

--------------------------------

### Send Raw HCI Command

Source: https://github.com/androidgolab/binder/blob/main/README.md

Send a raw HCI command to the Bluetooth controller, specified as hexadecimal bytes.

```bash
bindercli android.hardware.bluetooth.IBluetoothHci send-hci-command \
  --command 01030c00
```

--------------------------------

### Check Package Permission

Source: https://github.com/androidgolab/binder/blob/main/README.md

Check if a specific package holds a requested permission for a given user ID.

```bash
bindercli android.content.pm.IPackageManager check-permission \
  --permName android.permission.INTERNET \
  --pkgName com.android.settings --userId 0
```

--------------------------------

### Check Power State

Source: https://github.com/androidgolab/binder/blob/main/README.md

Checks if the device screen is interactive and if power save mode is enabled. Requires the kernel binder driver and a transport.

```go
import (
    "context"
    "fmt"
    "log"

    genOs "github.com/AndroidGoLab/binder/android/os"
    "github.com/AndroidGoLab/binder/binder"
    "github.com/AndroidGoLab/binder/binder/versionaware"
    "github.com/AndroidGoLab/binder/kernelbinder"
    "github.com/AndroidGoLab/binder/servicemanager"
)

    ctx := context.Background()

    driver, err := kernelbinder.Open(ctx, binder.WithMapSize(128*1024))
    if err != nil {
        log.Fatal(err)
    }
    defer driver.Close(ctx)

    transport, err := versionaware.NewTransport(ctx, driver, 0)
    if err != nil {
        log.Fatal(err)
    }
    sm := servicemanager.New(transport)

    power, err := genOs.GetPowerManager(ctx, sm)
    if err != nil {
        log.Fatal(err)
    }

    interactive, _ := power.IsInteractive(ctx)
    fmt.Printf("Screen on: %v\n", interactive)

    powerSave, _ := power.IsPowerSaveMode(ctx)
    fmt.Printf("Power save: %v\n", powerSave)
```

--------------------------------

### Configure Claude Code for Binder MCP

Source: https://github.com/androidgolab/binder/blob/main/README.md

Add binder-mcp as a transport for Claude Code using stdio. This command configures Claude Code to use the locally running binder-mcp in remote mode.

```bash
claude mcp add --transport stdio binder-mcp -- binder-mcp --mode remote
```

--------------------------------

### Generated Go Proxy for AIDL Interface

Source: https://github.com/androidgolab/binder/blob/main/README.md

The Go code generated from an AIDL interface, including constants, interface definition, and a proxy implementation for making Binder calls.

```go
package app

const DescriptorIActivityManager = "android.app.IActivityManager"

const (
    TransactionIActivityManagerGetProcessLimit  = binder.FirstCallTransaction + 51
    TransactionIActivityManagerCheckPermission  = binder.FirstCallTransaction + 8
    // ...
)

const (
    MethodIActivityManagerGetProcessLimit  = "getProcessLimit"
    MethodIActivityManagerCheckPermission  = "checkPermission"
    // ...
)

type IActivityManager interface {
    GetProcessLimit(ctx context.Context) (int32, error)
    CheckPermission(ctx context.Context, permission string, pid int32, uid int32) (int32, error)
    IsUserAMonkey(ctx context.Context) (bool, error)
    // ...
}

type ActivityManagerProxy struct {
    Remote binder.IBinder
}

func NewActivityManagerProxy(remote binder.IBinder) *ActivityManagerProxy {
    return &ActivityManagerProxy{Remote: remote}
}

func (p *ActivityManagerProxy) GetProcessLimit(ctx context.Context) (int32, error) {
    var _result int32
    _data := parcel.New()
    defer _data.Recycle()
    _data.WriteInterfaceToken(DescriptorIActivityManager)

    _code, _err := p.Remote.ResolveCode(ctx, DescriptorIActivityManager, MethodIActivityManagerGetProcessLimit)
    if _err != nil {
        return _result, fmt.Errorf("resolving %s.%s: %w", DescriptorIActivityManager, MethodIActivityManagerGetProcessLimit, _err)
    }

    _reply, _err := p.Remote.Transact(ctx, _code, 0, _data)
    if _err != nil {
        return _result, _err
    }
    defer _reply.Recycle()

    if _err = binder.ReadStatus(_reply); _err != nil {
        return _result, _err
    }

    _result, _err = _reply.ReadInt32()
    if _err != nil {
        return _result, _err
    }
    return _result, nil
}
```

--------------------------------

### Query Battery Level and Health Info

Source: https://github.com/androidgolab/binder/blob/main/README.md

Retrieve battery capacity, status, temperature, voltage, and current using the Health AIDL interface. Ensure the health service is available.

```go
import (
    "github.com/AndroidGoLab/binder/android/hardware/health"
    "github.com/AndroidGoLab/binder/servicemanager"
)

    svc, err := sm.GetService(ctx, servicemanager.ServiceName(health.DescriptorIHealth+"/default"))
    if err != nil {
        log.Fatal(err)
    }
    h := health.NewHealthProxy(svc)

    capacity, err := h.GetCapacity(ctx)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Battery level: %d%%\n", capacity)

    info, err := h.GetHealthInfo(ctx)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Status: %v, Temperature: %.1f °C\n",
        info.BatteryStatus, float64(info.BatteryTemperatureTenthsCelsius)/10)
    fmt.Printf("Voltage: %d mV, Current: %d µA\n",
        info.BatteryVoltageMillivolts, info.BatteryCurrentMicroamps)
```

--------------------------------

### Check Power Save Mode

Source: https://github.com/androidgolab/binder/blob/main/README.md

Determine if the device is currently operating in power save mode.

```bash
bindercli android.os.IPowerManager is-power-save-mode
```

--------------------------------

### Query Power Manager State

Source: https://github.com/androidgolab/binder/blob/main/README.md

This snippet shows how to query the Android PowerManager to check if the device screen is currently on. It requires obtaining a PowerManager instance first.

```go
power, _ := os.GetPowerManager(ctx, sm)
interactive, _ := power.IsInteractive(ctx)
fmt.Printf("Screen on: %v\n", interactive)
```

--------------------------------

### Send Raw Binder Transaction

Source: https://github.com/androidgolab/binder/blob/main/README.md

Manually construct a parcel, resolve a method's transaction code, and send a raw binder transaction to a service. This is useful for interfaces without generated Go proxies.

```go
import (
    "github.com/AndroidGoLab/binder/binder"
    "github.com/AndroidGoLab/binder/parcel"
    "github.com/AndroidGoLab/binder/servicemanager"
)

    svc, err := sm.GetService(ctx, servicemanager.ActivityService)
    if err != nil {
        log.Fatal(err)
    }

    // Build the request parcel.
    data := parcel.New()
    defer data.Recycle()
    data.WriteInterfaceToken("android.app.IActivityManager")
    data.WriteString16("android.permission.INTERNET")
    data.WriteInt32(int32(os.Getpid()))
    data.WriteInt32(int32(os.Getuid()))

    // Resolve the method's transaction code and send.
    code, err := svc.ResolveCode(ctx, "android.app.IActivityManager", "checkPermission")
    if err != nil {
        log.Fatal(err)
    }
    reply, err := svc.Transact(ctx, code, 0, data)
    if err != nil {
        log.Fatal(err)
    }
    defer reply.Recycle()

    // Read the AIDL status header, then the return value.
    if err := binder.ReadStatus(reply); err != nil {
        log.Fatal(err)
    }
    result, _ := reply.ReadInt32()
    fmt.Printf("checkPermission returned: %d\n", result)
```

--------------------------------

### Handle AIDL Errors

Source: https://github.com/androidgolab/binder/blob/main/README.md

Inspect AIDL errors using errors.As and a switch statement on the exception type. This is useful for differentiating between security, service-specific, and other AIDL errors.

```go
import (
    "errors"
    aidlerrors "github.com/AndroidGoLab/binder/errors"
    "github.com/AndroidGoLab/binder/servicemanager"
)

    // Non-blocking service check (returns nil if not found)
    svc, err := sm.CheckService(ctx, servicemanager.MediaCameraService)
    if err != nil {
        log.Fatal(err)
    }
    if svc == nil {
        fmt.Println("Camera service not available")
        return
    }

    // Typed error inspection
    _, err = someProxy.SomeMethod(ctx)
    var status *aidlerrors.StatusError
    if errors.As(err, &status) {
        switch status.Exception {
        case aidlerrors.ExceptionSecurity:
            fmt.Printf("Permission denied: %s\n", status.Message)
        case aidlerrors.ExceptionServiceSpecific:
            fmt.Printf("Service error %d: %s\n", status.ServiceSpecificCode, status.Message)
        default:
            fmt.Printf("AIDL error: %v\n", status)
        }
    }
```

--------------------------------

### Check Clipboard Text

Source: https://github.com/androidgolab/binder/blob/main/README.md

Determine if the device's clipboard currently contains text data. Requires specifying the calling package and user ID.

```bash
bindercli android.content.IClipboard has-clipboard-text \
  --callingPackage com.android.shell \
  --attributionTag "" --userId 0 --deviceId 0
```

--------------------------------

### Close Bluetooth HCI

Source: https://github.com/androidgolab/binder/blob/main/README.md

Close the Bluetooth Host Controller Interface (HCI) connection.

```bash
bindercli android.hardware.bluetooth.IBluetoothHci close
```

--------------------------------

### Check if User is Monkey

Source: https://github.com/androidgolab/binder/blob/main/README.md

Determine if the current user is controlled by an automated testing tool (monkey).

```bash
bindercli android.app.IActivityManager is-user-a-monkey
```
Tokens:
Raw