fix: run bindercli E2E tests on-device, exclude sub-interfaces from CLI

Two fixes:

1. E2E bindercli tests now exec the binary directly when running
   on-device instead of unconditionally skipping. Previously all 40
   bindercli tests were skipped on-device; now 23 pass, 17 skip
   (services unavailable on the specific device).

2. spec2cli detects sub-interfaces (returned by methods on other
   interfaces but not registered with ServiceManager) and excludes
   them from CLI command generation. These interfaces cannot be
   discovered by findServiceByDescriptor, so the generated commands
   always failed with "no service with descriptor ... found".

Author: xaionaro@dx.center

tests/e2e/aidlcli_test.go

@@ -37,13 +37,22 @@ var emulatorStartedByTest bool
 // onDevice reports whether the test binary is running directly on an
 // Android device (i.e. /dev/binder is accessible). When true, the
 // emulator/adb setup is skipped — on-device tests open /dev/binder
-// directly, and aidlcli tests are skipped.
+// directly, and bindercli tests exec the binary directly.
 var onDevice bool
 
+// bindercliAvailable is true when the bindercli binary exists at
+// deviceBinary. On-device, this requires the binary to have been
+// pushed separately; on-host it is built and pushed by TestMain.
+var bindercliAvailable bool
+
 func TestMain(m *testing.M) {
 	if _, err := os.Stat("/dev/binder"); err == nil {
 		// Running on the device itself — skip emulator setup.
+		// Bindercli tests will exec the binary directly if present.
 		onDevice = true
+		if _, err := os.Stat(deviceBinary); err == nil {
+			bindercliAvailable = true
+		}
 		os.Exit(m.Run())
 	}
 
@@ -199,11 +208,23 @@ func logAndExit(msg string) {
 	os.Exit(1)
 }
 
-// runBindercli executes bindercli on the emulator via `adb -s <serial> shell`.
+// runBindercli executes bindercli and returns stdout, stderr, error.
+// When running on the host, it uses `adb -s <serial> shell` to execute
+// on the emulator. When running on-device, it execs the binary directly.
 // It always injects --format json for machine-parseable output.
-// Arguments are joined into a single shell command string to preserve
-// empty/quoted values across the adb shell boundary.
 func runBindercli(args ...string) (string, string, error) {
+	if onDevice {
+		fullArgs := append([]string{"--format", "json"}, args...)
+		cmd := exec.Command(deviceBinary, fullArgs...)
+		var stdout, stderr bytes.Buffer
+		cmd.Stdout = &stdout
+		cmd.Stderr = &stderr
+		err := cmd.Run()
+		return stdout.String(), stderr.String(), err
+	}
+
+	// Host path: join into a single shell command string to preserve
+	// empty/quoted values across the adb shell boundary.
 	parts := make([]string, 0, len(args)+3)
 	parts = append(parts, deviceBinary, "--format", "json")
 	for _, a := range args {
@@ -230,12 +251,11 @@ func shellQuote(s string) string {
 	return "'" + strings.ReplaceAll(s, "'", "'\\''") + "'"
 }
 
-// runBindercliOrSkip runs bindercli; skips the test when the service is unavailable
-// or when running directly on the device (aidlcli tests require adb from the host).
+// runBindercliOrSkip runs bindercli; skips the test when the service is unavailable.
 func runBindercliOrSkip(t *testing.T, args ...string) string {
 	t.Helper()
-	if onDevice {
-		t.Skip("bindercli tests require adb from host; skipping on-device")
+	if onDevice && !bindercliAvailable {
+		t.Skip("bindercli binary not found on device at " + deviceBinary)
 	}
 	stdout, stderr, err := runBindercli(args...)
 	if err != nil {
@@ -701,8 +721,8 @@ func runBindercliHALOrSkip(
 	args ...string,
 ) string {
 	t.Helper()
-	if onDevice {
-		t.Skip("bindercli tests require adb from host; skipping on-device")
+	if onDevice && !bindercliAvailable {
+		t.Skip("bindercli binary not found on device at " + deviceBinary)
 	}
 	fullArgs := append([]string{serviceName}, args...)
 	stdout, stderr, err := runBindercli(fullArgs...)
@@ -745,8 +765,8 @@ func TestBindercli_ServiceMethods(t *testing.T) {
 }
 
 func TestBindercli_ServiceTransact(t *testing.T) {
-	if onDevice {
-		t.Skip("bindercli tests require adb from host; skipping on-device")
+	if onDevice && !bindercliAvailable {
+		t.Skip("bindercli binary not found on device at " + deviceBinary)
 	}
 
 	// SurfaceFlinger code 1022 (getSchedulingPolicy) is a simple read-only

tools/cmd/spec2cli/main.go

@@ -122,6 +122,12 @@ var knownServiceNames map[string]string
 // resolving interface types (kindInterfaceType) in other packages.
 var knownInterfaces map[string]*interfaceInfo
 
+// subInterfaceDescriptors is the set of AIDL descriptors that are
+// returned by methods on other interfaces but are NOT registered with
+// ServiceManager. These cannot be discovered by findServiceByDescriptor
+// and are excluded from top-level CLI command generation.
+var subInterfaceDescriptors map[string]bool
+
 func main() {
 	specsDir := flag.String("specs", "specs/", "Directory containing spec YAML files")
 	outputDir := flag.String("output", "cmd/bindercli/", "Output directory for generated files")
@@ -162,8 +168,34 @@ func run(
 	fmt.Fprintf(os.Stderr, "Scanned enum types: %d\n", len(knownEnums))
 	fmt.Fprintf(os.Stderr, "Known service mappings: %d\n", len(knownServiceNames))
 
-	// Phase 2: build interface list.
+	// Phase 2: build interface list and detect sub-interfaces.
+	//
+	// A sub-interface is one that appears as a return type of a method on
+	// another interface but is not registered with ServiceManager. These
+	// cannot be discovered via findServiceByDescriptor and should not get
+	// top-level CLI commands.
 	var interfaces []*interfaceInfo
+
+	// Collect all interface descriptors that appear as method return types.
+	// These are potential sub-interfaces (obtained via a parent, not via
+	// ServiceManager).
+	returnedDescriptors := map[string]bool{}
+	for _, ps := range specs {
+		for _, iface := range ps.Interfaces {
+			for _, m := range iface.Methods {
+				rt := m.ReturnType.Name
+				if rt == "" {
+					continue
+				}
+				// Qualify unqualified names with the current package.
+				if !strings.Contains(rt, ".") && ps.AIDLPackage != "" {
+					rt = ps.AIDLPackage + "." + rt
+				}
+				returnedDescriptors[rt] = true
+			}
+		}
+	}
+
 	for _, ps := range specs {
 		importPath := modulePath + "/" + ps.GoPackage
 		pkgName := filepath.Base(ps.GoPackage)
@@ -179,6 +211,19 @@ func run(
 		return interfaces[i].Descriptor < interfaces[j].Descriptor
 	})
 
+	// Identify sub-interfaces: descriptors that appear as method return
+	// types but have no ServiceManager registration.
+	subInterfaceDescriptors = map[string]bool{}
+	for _, ii := range interfaces {
+		if _, hasMapping := knownServiceNames[ii.Descriptor]; hasMapping {
+			continue
+		}
+		if returnedDescriptors[ii.Descriptor] {
+			subInterfaceDescriptors[ii.Descriptor] = true
+		}
+	}
+	fmt.Fprintf(os.Stderr, "Sub-interfaces (excluded from CLI): %d\n", len(subInterfaceDescriptors))
+
 	totalMethods := 0
 	commandableMethods := 0
 	for _, iface := range interfaces {
@@ -1009,6 +1054,11 @@ func writeCommandsGen(
 		if iface.ImportPath == modulePath {
 			continue
 		}
+		// Skip sub-interfaces: they are obtained via methods on other
+		// interfaces and cannot be discovered by findServiceByDescriptor.
+		if subInterfaceDescriptors[iface.Descriptor] {
+			continue
+		}
 
 		var cmdMethods []methodInfo
 		for _, m := range iface.Methods {