feat: binder-mcp P0 tools — power, display, packages, audio, camera, network, battery

Add 22 new MCP tools covering device state inspection and control:

Binder-based (via raw parcel transactions):
- is_screen_on, wake_screen, sleep_screen (IPowerManager)
- get_brightness, set_brightness (IDisplayManager)
- get_display_size (IWindowManager)
- list_packages, get_package_info (IPackageManager)
- stop_app (IActivityManager.forceStopPackage)
- list_cameras (ICameraService.getNumberOfCameras)
- get_media_volume, set_media_volume (IAudioService)
- get_bluetooth_state (IBluetoothManager.getState)

Shell-based (dumpsys/sysfs fallbacks for complex parcelables):
- get_clipboard, set_clipboard
- launch_app (monkey/am start)
- get_current_app, get_focused_activity (dumpsys activity)
- get_wifi_state (cmd wifi status)
- get_telephony_info (dumpsys telephony.registry)
- list_notifications (dumpsys notification)
- get_battery_info (dumpsys battery / sysfs)

All tools verified on-device via MCP JSON-RPC.

Author: xaionaro@dx.center

cmd/binder-mcp/tool_get_battery_info.go

@@ -0,0 +1,152 @@
+//go:build linux
+
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"github.com/facebookincubator/go-belt/tool/logger"
+	"github.com/mark3labs/mcp-go/mcp"
+	"github.com/mark3labs/mcp-go/server"
+)
+
+// BatteryInfoResult holds the get_battery_info response.
+type BatteryInfoResult struct {
+	Level       string `json:"level"`
+	Status      string `json:"status"`
+	Temperature string `json:"temperature,omitempty"`
+	Voltage     string `json:"voltage,omitempty"`
+	Technology  string `json:"technology,omitempty"`
+	Health      string `json:"health,omitempty"`
+	Error       string `json:"error,omitempty"`
+}
+
+func registerGetBatteryInfo(s *server.MCPServer) {
+	tool := mcp.NewTool("get_battery_info",
+		mcp.WithDescription(
+			"Get battery information (level, status, temperature, voltage) "+
+				"from /sys/class/power_supply/ sysfs entries. More reliable "+
+				"than binder for shell UID.",
+		),
+		mcp.WithReadOnlyHintAnnotation(true),
+		mcp.WithDestructiveHintAnnotation(false),
+		mcp.WithIdempotentHintAnnotation(true),
+	)
+
+	s.AddTool(tool, handleGetBatteryInfo)
+}
+
+func handleGetBatteryInfo(
+	ctx context.Context,
+	_ mcp.CallToolRequest,
+) (*mcp.CallToolResult, error) {
+	logger.Tracef(ctx, "handleGetBatteryInfo")
+	defer func() { logger.Tracef(ctx, "/handleGetBatteryInfo") }()
+
+	result := BatteryInfoResult{}
+
+	// Try dumpsys battery first (most reliable on Android).
+	out, err := shellExec("dumpsys battery")
+	if err == nil {
+		result = parseBatteryDumpsys(out)
+	} else {
+		// Fall back to sysfs.
+		result = readBatterySysfs()
+	}
+
+	data, err := json.Marshal(result)
+	if err != nil {
+		return nil, fmt.Errorf("marshaling battery info: %w", err)
+	}
+
+	return mcp.NewToolResultText(string(data)), nil
+}
+
+func parseBatteryDumpsys(output string) BatteryInfoResult {
+	result := BatteryInfoResult{}
+	for _, line := range strings.Split(output, "\n") {
+		line = strings.TrimSpace(line)
+		parts := strings.SplitN(line, ":", 2)
+		if len(parts) != 2 {
+			continue
+		}
+		key := strings.TrimSpace(parts[0])
+		val := strings.TrimSpace(parts[1])
+		switch key {
+		case "level":
+			result.Level = val
+		case "status":
+			result.Status = batteryStatusName(val)
+		case "temperature":
+			result.Temperature = val
+		case "voltage":
+			result.Voltage = val
+		case "technology":
+			result.Technology = val
+		case "health":
+			result.Health = batteryHealthName(val)
+		}
+	}
+	return result
+}
+
+func readBatterySysfs() BatteryInfoResult {
+	result := BatteryInfoResult{}
+	readSysfs := func(path string) string {
+		out, err := shellExec("cat " + path + " 2>/dev/null")
+		if err != nil {
+			return ""
+		}
+		return strings.TrimSpace(out)
+	}
+
+	result.Level = readSysfs("/sys/class/power_supply/battery/capacity")
+	result.Status = readSysfs("/sys/class/power_supply/battery/status")
+	result.Temperature = readSysfs("/sys/class/power_supply/battery/temp")
+	result.Voltage = readSysfs("/sys/class/power_supply/battery/voltage_now")
+	result.Technology = readSysfs("/sys/class/power_supply/battery/technology")
+	result.Health = readSysfs("/sys/class/power_supply/battery/health")
+
+	return result
+}
+
+func batteryStatusName(code string) string {
+	switch code {
+	case "1":
+		return "unknown"
+	case "2":
+		return "charging"
+	case "3":
+		return "discharging"
+	case "4":
+		return "not_charging"
+	case "5":
+		return "full"
+	default:
+		return code
+	}
+}
+
+func batteryHealthName(code string) string {
+	switch code {
+	case "1":
+		return "unknown"
+	case "2":
+		return "good"
+	case "3":
+		return "overheat"
+	case "4":
+		return "dead"
+	case "5":
+		return "over_voltage"
+	case "6":
+		return "failure"
+	case "7":
+		return "cold"
+	default:
+		return code
+	}
+}

cmd/binder-mcp/tool_get_bluetooth_state.go

@@ -0,0 +1,123 @@
+//go:build linux
+
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"github.com/facebookincubator/go-belt/tool/logger"
+	"github.com/mark3labs/mcp-go/mcp"
+	"github.com/mark3labs/mcp-go/server"
+
+	"github.com/AndroidGoLab/binder/binder"
+	"github.com/AndroidGoLab/binder/parcel"
+	"github.com/AndroidGoLab/binder/servicemanager"
+)
+
+const bluetoothManagerDescriptor = "android.bluetooth.IBluetoothManager"
+
+// BluetoothState maps the int32 returned by IBluetoothManager.getState().
+type BluetoothState int32
+
+const (
+	BluetoothStateOff          BluetoothState = 10
+	BluetoothStateTurningOn    BluetoothState = 11
+	BluetoothStateOn           BluetoothState = 12
+	BluetoothStateTurningOff   BluetoothState = 13
+	BluetoothStateBLETurningOn BluetoothState = 14
+	BluetoothStateBLEOn        BluetoothState = 15
+	BluetoothStateBLETurnOff   BluetoothState = 16
+)
+
+// BluetoothStateResult holds the get_bluetooth_state response.
+type BluetoothStateResult struct {
+	StateCode int32  `json:"state_code"`
+	State     string `json:"state"`
+	Error     string `json:"error,omitempty"`
+}
+
+func (ts *ToolSet) registerGetBluetoothState(s *server.MCPServer) {
+	tool := mcp.NewTool("get_bluetooth_state",
+		mcp.WithDescription(
+			"Get the Bluetooth adapter state using IBluetoothManager.getState(). "+
+				"Returns state_code and human-readable state (off/turning_on/on/turning_off).",
+		),
+		mcp.WithReadOnlyHintAnnotation(true),
+		mcp.WithDestructiveHintAnnotation(false),
+		mcp.WithIdempotentHintAnnotation(true),
+	)
+
+	s.AddTool(tool, ts.handleGetBluetoothState)
+}
+
+func (ts *ToolSet) handleGetBluetoothState(
+	ctx context.Context,
+	_ mcp.CallToolRequest,
+) (*mcp.CallToolResult, error) {
+	logger.Tracef(ctx, "handleGetBluetoothState")
+	defer func() { logger.Tracef(ctx, "/handleGetBluetoothState") }()
+
+	svc, err := ts.sm.CheckService(ctx, servicemanager.ServiceName("bluetooth_manager"))
+	if err != nil || svc == nil {
+		return mcp.NewToolResultError("bluetooth_manager service unavailable"), nil
+	}
+
+	code, err := svc.ResolveCode(ctx, bluetoothManagerDescriptor, "getState")
+	if err != nil {
+		return mcp.NewToolResultError(fmt.Sprintf("resolving getState: %v", err)), nil
+	}
+
+	data := parcel.New()
+	defer data.Recycle()
+	data.WriteInterfaceToken(bluetoothManagerDescriptor)
+
+	reply, err := svc.Transact(ctx, code, 0, data)
+	if err != nil {
+		return mcp.NewToolResultError(fmt.Sprintf("getState: %v", err)), nil
+	}
+	defer reply.Recycle()
+
+	if err := binder.ReadStatus(reply); err != nil {
+		return mcp.NewToolResultError(fmt.Sprintf("getState status: %v", err)), nil
+	}
+
+	stateCode, err := reply.ReadInt32()
+	if err != nil {
+		return mcp.NewToolResultError(fmt.Sprintf("reading state: %v", err)), nil
+	}
+
+	result := BluetoothStateResult{
+		StateCode: stateCode,
+		State:     bluetoothStateString(BluetoothState(stateCode)),
+	}
+
+	out, err := json.Marshal(result)
+	if err != nil {
+		return nil, fmt.Errorf("marshaling bluetooth state: %w", err)
+	}
+
+	return mcp.NewToolResultText(string(out)), nil
+}
+
+func bluetoothStateString(state BluetoothState) string {
+	switch state {
+	case BluetoothStateOff:
+		return "off"
+	case BluetoothStateTurningOn:
+		return "turning_on"
+	case BluetoothStateOn:
+		return "on"
+	case BluetoothStateTurningOff:
+		return "turning_off"
+	case BluetoothStateBLETurningOn:
+		return "ble_turning_on"
+	case BluetoothStateBLEOn:
+		return "ble_on"
+	case BluetoothStateBLETurnOff:
+		return "ble_turning_off"
+	default:
+		return fmt.Sprintf("unknown(%d)", state)
+	}
+}

cmd/binder-mcp/tool_get_brightness.go

@@ -0,0 +1,83 @@
+//go:build linux
+
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"github.com/facebookincubator/go-belt/tool/logger"
+	"github.com/mark3labs/mcp-go/mcp"
+	"github.com/mark3labs/mcp-go/server"
+
+	"github.com/AndroidGoLab/binder/binder"
+	"github.com/AndroidGoLab/binder/parcel"
+	"github.com/AndroidGoLab/binder/servicemanager"
+)
+
+// BrightnessResult holds the get_brightness response.
+type BrightnessResult struct {
+	Brightness float32 `json:"brightness"`
+	Error      string  `json:"error,omitempty"`
+}
+
+func (ts *ToolSet) registerGetBrightness(s *server.MCPServer) {
+	tool := mcp.NewTool("get_brightness",
+		mcp.WithDescription(
+			"Get the current display brightness level (0.0 to 1.0) from "+
+				"IDisplayManager.getBrightness().",
+		),
+		mcp.WithReadOnlyHintAnnotation(true),
+		mcp.WithDestructiveHintAnnotation(false),
+		mcp.WithIdempotentHintAnnotation(true),
+	)
+
+	s.AddTool(tool, ts.handleGetBrightness)
+}
+
+func (ts *ToolSet) handleGetBrightness(
+	ctx context.Context,
+	_ mcp.CallToolRequest,
+) (*mcp.CallToolResult, error) {
+	logger.Tracef(ctx, "handleGetBrightness")
+	defer func() { logger.Tracef(ctx, "/handleGetBrightness") }()
+
+	svc, err := ts.sm.CheckService(ctx, servicemanager.ServiceName("display"))
+	if err != nil || svc == nil {
+		return mcp.NewToolResultError("display service unavailable"), nil
+	}
+
+	code, err := svc.ResolveCode(ctx, displayManagerDescriptor, "getBrightness")
+	if err != nil {
+		return mcp.NewToolResultError(fmt.Sprintf("resolving getBrightness: %v", err)), nil
+	}
+
+	data := parcel.New()
+	defer data.Recycle()
+	data.WriteInterfaceToken(displayManagerDescriptor)
+	// getBrightness(int displayId) -- use display 0 (default).
+	data.WriteInt32(0)
+
+	reply, err := svc.Transact(ctx, code, 0, data)
+	if err != nil {
+		return mcp.NewToolResultError(fmt.Sprintf("getBrightness: %v", err)), nil
+	}
+	defer reply.Recycle()
+
+	if err := binder.ReadStatus(reply); err != nil {
+		return mcp.NewToolResultError(fmt.Sprintf("getBrightness status: %v", err)), nil
+	}
+
+	brightness, err := reply.ReadFloat32()
+	if err != nil {
+		return mcp.NewToolResultError(fmt.Sprintf("reading brightness: %v", err)), nil
+	}
+
+	out, err := json.Marshal(BrightnessResult{Brightness: brightness})
+	if err != nil {
+		return nil, fmt.Errorf("marshaling brightness: %w", err)
+	}
+
+	return mcp.NewToolResultText(string(out)), nil
+}