Socket open failed at AdbPacketDispatcher.handleClose

[tommyjtl]

I'm currently writing a minimal demo with Redux based on the v0.0.20 version. However, when I was trying to call spawnAndWait(), it always warned me about Socket open failed. But when I try shell(), it returned something.

Here's a function that handles my "Run Command" button:

  const handleRunCommand = useCallback(async () => {
    if (!currentDevice) {
      console.log("no device selected");
      return;
    }

    // const result = await currentDevice.rm("/mnt/UDISK/hello.py")
    // const result = await currentDevice.subprocess.shell(["ls"]);
    const result = await currentDevice.subprocess.spawnAndWait(["ls", "/opt"])
    console.log(result);
  }, [
    currentDevice,
  ]);

In the code above – as previously mentioned – it works only when I ran with const result = await currentDevice.subprocess.shell(["ls"]);, and it returns a AdbSubprocessNoneProtocol object, which is something look like this:

When I ran with const result = await currentDevice.subprocess.spawnAndWait(["ls", "/opt"]) or const result = await currentDevice.rm("/mnt/UDISK/hello.py"), it prompted an error modal and doesn't return anything, , here's how it looks:

I also tried the native adb shell ls in my terminal, and it worked very well. Is there something I missed? Please help me figure out this problem, thanks!

Here's my full code

const Home: React.FC = () => {
  const currentBackend = useSelector((state: AppState) => state.currentBackend);
  const currentDevice = useSelector((state: AppState) => state.currentDevice);

  const credentialStore = useSelector(
    (state: AppState) => state.credentialStore,
  );
  const browserSupported = useSelector(
    (state: AppState) => state.browserSupported,
  );
  const isBackendConnecting = useSelector(
    (state: AppState) => state.isBackendConnecting,
  );
  const isBackendConnected = useSelector(
    (state: AppState) => state.isBackendConnected,
  );

  const dispatch = useDispatch();

  // const handleMessageChange = (e: React.ChangeEvent<HTMLTextAreaElement>) => {
  //   dispatch(updateMessage(e.target.value));
  // };

  const handleSelectDevice = async () => {
    const CredentialStore = new AdbWebCredentialStore();

    dispatch(updateCredentialStore(CredentialStore));

    if (!AdbDaemonWebUsbDeviceManager.BROWSER) {
      // browser not supported
      dispatch(updateBrowserSupported(false));
      return;
    }

    dispatch(updateBrowserSupported(true));

    const backend = await AdbDaemonWebUsbDeviceManager.BROWSER.requestDevice();

    if (!backend) {
      // no device chosen by user
      dispatch(updateCurrentBackend(undefined));
      return;
    }

    dispatch(updateCurrentBackend(backend));
  };

  const handleConnect = useCallback(async () => {
    if (!currentBackend) {
      console.log("no backend selected");
      return;
    }

    dispatch(updateIsBackendConnecting(true));

    let readable: ReadableStream<AdbPacketData>;
    let writable: WritableStream<Consumable<AdbPacketInit>>;
    
    // construting the streams
    try {
      const streams = await currentBackend.connect();

      // Use `InspectStream`s to intercept and log packets
      readable = streams.readable.pipeThrough(
        new InspectStream((packet) => {
          dispatch(appendLog({ direction: "in", ...packet }));
        }),
      );

      writable = pipeFrom(
        streams.writable,
        new InspectStream((packet: Consumable<AdbPacketInit>) => {
          dispatch(appendLog({ direction: "out", ...packet.value }));
        }),
      );

    } catch (e: any) {
      console.log("error connecting", e);
      dispatch(updateIsBackendConnecting(false));
      return;
    }

    async function dispose() {
      // Adb won't close the streams,
      // so manually close them.
      try {
        readable.cancel();
      } catch {
        // ignore error
        console.log("error closing readable");
      }

      try {
        await writable.close();
      } catch {
        // ignore error
        console.log("error closing writable");
      }

      // do we need to reset the device?
      // GLOBAL_STATE.setDevice(undefined, undefined);
      dispatch(updateCurrentDevice(undefined));
    }

    // constructing the device
    try {
      const device = new Adb(
        await AdbDaemonTransport.authenticate({
          serial: currentBackend.serial,
          connection: {readable, writable},
          credentialStore: credentialStore,
        }),
      );

      device.disconnected.then(
        async () => {
          console.log("Disconnected");
          await dispose();
        },
        async (e) => {
          console.log("Connecting failed", e);
          await dispose();
        },
      );

      dispatch(updateCurrentDevice(device));

      if (!device) {
        console.log("no device selected");
        return;
      }

      dispatch(updateIsBackendConnected(true));
    } catch (e: any) {
      console.log("error connecting", e);
      await dispose();
    } finally {
      dispatch(updateIsBackendConnecting(false));
      console.log("Connected");
    }

  }, [
    currentBackend, 
    currentDevice,
    isBackendConnected, 
    isBackendConnecting,
  ]);

  const handleRunCommand = useCallback(async () => {
    if (!currentDevice) {
      console.log("no device selected");
      return;
    }
    // console.log("current device", currentDevice.serial);

    // const result = await currentDevice.rm("/mnt/UDISK/hello.py")
    const result = await currentDevice.subprocess.spawnAndWait(["ls", "/opt"])
    // const result = await currentDevice.subprocess.shell(["ls"]);
    console.log(result);
  }, [
    currentDevice,
  ]);

  const handleDisconnect = useCallback(async () => {
    try {
      await currentDevice!.close();
    } catch (e: any) {
      console.log("error disconnecting", e);
    } finally {
      dispatch(updateCurrentDevice(undefined));
      dispatch(updateIsBackendConnected(false));
    }
  }, [
    currentDevice
  ]);

  useEffect(() => {
    console.log("brwoser supported", browserSupported);
    console.log("current backend", currentBackend);
  }, [browserSupported, currentBackend]);

  return (
    <Space direction="vertical" style={{ width: "100%" }} size={[0, 48]}>
      <Layout>
        <Content style={contentStyle}>
          <Row
            style={{
              paddingTop: "200px",
            }}
          >
            <Col span={4}></Col>

            <Col span={16}>
              <Space wrap>
                <Button type="primary" onClick={handleSelectDevice}>
                  Select
                </Button>

                {!isBackendConnected ? 
                  <Button 
                    type="primary" 
                    onClick={handleConnect}
                    // disabled={isBackendConnected || isBackendConnecting}
                  >
                    Connect
                  </Button> :
                  <Button 
                    type="primary" 
                    onClick={handleDisconnect}
                    danger
                    // disabled={isBackendConnected || isBackendConnecting}
                  >
                    Disconnect
                  </Button> 
                }

                <Button type="primary" onClick={handleRunCommand}>
                  Run Command
                </Button>
              </Space>
            </Col>

            <Col span={4}></Col>
          </Row>
        </Content>
      </Layout>
    </Space>
  );
};

[tommyjtl]

@yume-chan

[yume-chan]

What's your device and its Android version? Does currentDevice.subprocess.spawn(["ls"]) work? Does adb exec-out ls work?

[tommyjtl]

Unfortunately, neither of them works. However, when I switched to my daily Android phone (OnePlus 8), spawn works.

My previous non-working adb device is not a mobile phone, but rather a minimal Linux device that supports adb shell connection via OTG. So now I guess there's something wrong with the device itself, for example, it doesn't have the full adb server packed in the system – but I'm not sure. Could you help me identify what could be the core issue(s) if adb exec-out ls doesn't work on a certain device? Maybe something incompatible with the protocol using adb exec-out?

Here's the output when I ran adb exec-out ls on this non-usual adb device in the terminal:

$ adb exec-out ls
* daemon not running; starting now at tcp:5037
* daemon started successfully
error: closed

[yume-chan]

It's not practical to build adb daemon for normal Linux, it depends on too many things from Android. For example, you can't build adb without the full Android toolchain and a complete AOSP source clone.

This means, it's highly possible that the manufacturer of your device implemented a subset of adb commands to simplify debugging: the users don't need to install a special program, and adb client is available on many desktop operating systems.

[tommyjtl]

From what I understand so far, I think they just utilized USB adb forwarding via OTG. But that's fine, current shell method works fine with most scenarios. Thanks :D