/// <summary> /// Runs a log service on the <seealso cref="Device"/>, and provides its output to the <seealso cref="LogReceiver"/>. /// <p/>This call is blocking until <seealso cref="LogReceiver#isCancelled()"/> returns true. </summary> /// <param name="adbSockAddr"> the socket address to connect to adb </param> /// <param name="device"> the Device on which to run the service </param> /// <param name="logName"> the name of the log file to output </param> /// <param name="rcvr"> the <seealso cref="LogReceiver"/> to receive the log output </param> /// <exception cref="TimeoutException"> in case of timeout on the connection. </exception> /// <exception cref="AdbCommandRejectedException"> if adb rejects the command </exception> /// <exception cref="IOException"> in case of I/O error on the connection. </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public static void runLogService(java.net.InetSocketAddress adbSockAddr, Device device, String logName, com.android.ddmlib.log.LogReceiver rcvr) throws TimeoutException, AdbCommandRejectedException, java.io.IOException public static void runLogService(EndPoint adbSockAddr, Device device, string logName, LogReceiver rcvr) { SocketChannel adbChan = null; try { adbChan = SocketChannel.open(adbSockAddr); adbChan.configureBlocking(false); // if the device is not -1, then we first tell adb we're looking to talk // to a specific device setDevice(adbChan, device); var request = formAdbRequest("log:" + logName); write(adbChan, request); AdbResponse resp = readAdbResponse(adbChan, false); // readDiagString if (resp.okay == false) { throw new AdbCommandRejectedException(resp.message); } var data = new byte[16384]; ByteBuffer buf = ByteBuffer.wrap(data); while (true) { int count; if (rcvr != null && rcvr.cancelled) { break; } count = adbChan.read(buf); if (count < 0) { break; } else if (count == 0) { Thread.Sleep(WAIT_TIME * 5); } else { if (rcvr != null) { rcvr.parseNewData(buf.array(), buf.arrayOffset(), buf.position); } buf.rewind(); } } } finally { if (adbChan != null) { adbChan.close(); } } }
public void ExecuteRemoteCommandUnresponsiveTest() { var device = new DeviceData() { Serial = "169.254.109.177:5555", State = DeviceState.Online }; var responses = new AdbResponse[] { AdbResponse.OK, AdbResponse.OK }; var responseMessages = new string[] { }; var requests = new string[] { "host:transport:169.254.109.177:5555", "shell:echo Hello, World" }; var receiver = new ConsoleOutputReceiver(); Assert.Throws <ShellCommandUnresponsiveException>(() => this.RunTest( responses, responseMessages, requests, null, () => { this.TestClient.ExecuteRemoteCommand("echo Hello, World", device, receiver); })); }
public void ListReverseForwardTest() { var responseMessages = new string[] { "(reverse) localabstract:scrcpy tcp:100\n(reverse) localabstract: scrcpy2 tcp:100\n(reverse) localabstract: scrcpy3 tcp:100\n" }; var responses = new AdbResponse[] { AdbResponse.OK, AdbResponse.OK, }; var requests = new string[] { "host:transport:169.254.109.177:5555", "reverse:list-forward" }; ForwardData[] forwards = null; this.RunTest( responses, responseMessages, requests, () => forwards = this.TestClient.ListReverseForward(Device).ToArray()); Assert.NotNull(forwards); Assert.Equal(3, forwards.Length); Assert.Equal("(reverse)", forwards[0].SerialNumber); Assert.Equal("localabstract:scrcpy", forwards[0].Local); Assert.Equal("tcp:100", forwards[0].Remote); }
/// <summary> /// Remove a port forwarding between a local and a remote port. </summary> /// <param name="adbSockAddr"> the socket address to connect to adb </param> /// <param name="device"> the device on which to remove the port fowarding </param> /// <param name="localPort"> the local port of the forward </param> /// <param name="remotePort"> the remote port. </param> /// <exception cref="TimeoutException"> in case of timeout on the connection. </exception> /// <exception cref="AdbCommandRejectedException"> if adb rejects the command </exception> /// <exception cref="IOException"> in case of I/O error on the connection. </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public static void removeForward(java.net.InetSocketAddress adbSockAddr, Device device, int localPort, int remotePort) throws TimeoutException, AdbCommandRejectedException, java.io.IOException public static void removeForward(EndPoint adbSockAddr, Device device, int localPort, int remotePort) { SocketChannel adbChan = null; try { adbChan = SocketChannel.open(adbSockAddr); adbChan.configureBlocking(false); var request = formAdbRequest(string.Format("host-serial:{0}:killforward:tcp:{1:D};tcp:{2:D}", device.serialNumber, localPort, remotePort)); //$NON-NLS-1$ write(adbChan, request); AdbResponse resp = readAdbResponse(adbChan, false); // readDiagString if (resp.okay == false) { Log.w("remove-forward", "Error creating forward: " + resp.message); throw new AdbCommandRejectedException(resp.message); } } finally { if (adbChan != null) { adbChan.close(); } } }
/// <summary> /// Reads the response from ADB after a command. </summary> /// <param name="chan"> The socket channel that is connected to adb. </param> /// <param name="readDiagString"> If true, we're expecting an OKAY response to be /// followed by a diagnostic string. Otherwise, we only expect the /// diagnostic string to follow a FAIL. </param> /// <exception cref="TimeoutException"> in case of timeout on the connection. </exception> /// <exception cref="IOException"> in case of I/O error on the connection. </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: static AdbResponse readAdbResponse(java.nio.channels.SocketChannel chan, boolean readDiagString) throws TimeoutException, java.io.IOException internal static AdbResponse readAdbResponse(SocketChannel chan, bool readDiagString) { AdbResponse resp = new AdbResponse(); var reply = new byte[4]; read(chan, reply); if (isOkay(reply)) { resp.okay = true; } else { readDiagString = true; // look for a reason after the FAIL resp.okay = false; } // not a loop -- use "while" so we can use "break" try { while (readDiagString) { // length string is in next 4 bytes var lenBuf = new byte[4]; read(chan, lenBuf); string lenStr = replyToString(lenBuf); int len; try { len = Convert.ToInt32(lenStr, 16); } catch (SystemException) { Log.w("ddms", "Expected digits, got '" + lenStr + "': " + lenBuf[0] + " " + lenBuf[1] + " " + lenBuf[2] + " " + lenBuf[3]); Log.w("ddms", "reply was " + replyToString(reply)); break; } var msg = new byte[len]; read(chan, msg); resp.message = replyToString(msg); Log.v("ddms", "Got reply '" + replyToString(reply) + "', diag='" + resp.message + "'"); break; } } catch (Exception) { // ignore those, since it's just reading the diagnose string, the response will // contain okay==false anyway. } return(resp); }
public void Constructor_ValidatesArguments() { var response = new AdbResponse(AdbResponseStatus.OKAY, string.Empty); Assert.Equal(AdbResponseStatus.OKAY, response.Status); Assert.Equal(string.Empty, response.Message); response = new AdbResponse(AdbResponseStatus.FAIL, "ai"); Assert.Equal(AdbResponseStatus.FAIL, response.Status); Assert.Equal("ai", response.Message); }
public static AdbResponse Print(this AdbResponse response) { Console.Write(response.State + ":"); try { Console.Write(response.DataAsString()); } catch (Exception ex) { //Console.WriteLine(ex); } Console.Write("\n"); return(response); }
public void SetInvalidDeviceTest() { var requests = new string[] { "host:transport:169.254.109.177:5555" }; this.RunTest( new AdbResponse[] { AdbResponse.FromError("device not found") }, NoResponseMessages, requests, () => { AdbClient.Instance.SetDevice(this.Socket, Device); }); }
public void SetDeviceOtherException() { var requests = new string[] { "host:transport:169.254.109.177:5555" }; this.RunTest( new AdbResponse[] { AdbResponse.FromError("Too many cats.") }, NoResponseMessages, requests, () => { AdbClient.Instance.SetDevice(this.Socket, Device); }); }
public void SetInvalidDeviceTest() { var requests = new string[] { "host:transport:169.254.109.177:5555" }; Assert.Throws <DeviceNotFoundException>(() => this.RunTest( new AdbResponse[] { AdbResponse.FromError("device not found") }, NoResponseMessages, requests, () => { this.Socket.SetDevice(Device); })); }
public void SetDeviceOtherException() { var requests = new string[] { "host:transport:169.254.109.177:5555" }; Assert.Throws <AdbException>(() => this.RunTest( new AdbResponse[] { AdbResponse.FromError("Too many cats.") }, NoResponseMessages, requests, () => { this.Socket.SetDevice(Device); })); }
/// <summary> /// Reads the response from ADB after a command. </summary> /// <param name="readDiagString"> If true, we're expecting an OKAY response to be /// followed by a diagnostic string. Otherwise, we only expect the /// diagnostic string to follow a FAIL. </param> protected AdbResponse ReadAdbResponse(bool readDiagString) { var resp = new AdbResponse(); var reply = new byte[4]; Read(reply); if (IsOkay(reply)) { resp.Okay = true; } else { readDiagString = true; // look for a reason after the FAIL resp.Okay = false; } // not a loop -- use "while" so we can use "break" try { while (readDiagString) { int len; if (!TryReadHex4(out len)) { break; } var msg = new byte[len]; Read(msg); resp.Message = ReplyToString(msg); //Log.v("ddms", "Got reply '" + replyToString(reply) + "', diag='" + resp.message + "'"); break; } } catch (Exception) { // ignore those, since it's just reading the diagnose string, the response will // contain okay==false anyway. } return(resp); }
/// <summary> /// tells adb to talk to a specific device /// </summary> /// <param name="adbChan"> the socket connection to adb </param> /// <param name="device"> The device to talk to. </param> /// <exception cref="TimeoutException"> in case of timeout on the connection. </exception> /// <exception cref="AdbCommandRejectedException"> if adb rejects the command </exception> /// <exception cref="IOException"> in case of I/O error on the connection. </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: static void setDevice(java.nio.channels.SocketChannel adbChan, IDevice device) throws TimeoutException, AdbCommandRejectedException, java.io.IOException internal static void setDevice(SocketChannel adbChan, IDevice device) { // if the device is not -1, then we first tell adb we're looking to talk // to a specific device if (device != null) { string msg = "host:transport:" + device.serialNumber; //$NON-NLS-1$ var device_query = formAdbRequest(msg); write(adbChan, device_query); AdbResponse resp = readAdbResponse(adbChan, false); // readDiagString if (resp.okay == false) { throw new AdbCommandRejectedException(resp.message, true); //errorDuringDeviceSelection } } }
public void ReadLogTest() { var device = new DeviceData() { Serial = "169.254.109.177:5555", State = DeviceState.Online }; var responses = new AdbResponse[] { AdbResponse.OK, AdbResponse.OK }; var responseMessages = new string[] { }; var requests = new string[] { "host:transport:169.254.109.177:5555", "shell:logcat -B -b system" }; var receiver = new ConsoleOutputReceiver(); using (Stream stream = File.OpenRead("logcat.bin")) using (ShellStream shellStream = new ShellStream(stream, false)) { Collection <Logs.LogEntry> logs = new Collection <LogEntry>(); Action <LogEntry> sink = (entry) => logs.Add(entry); this.RunTest( responses, responseMessages, requests, shellStream, () => { this.TestClient.RunLogServiceAsync(device, sink, CancellationToken.None, Logs.LogId.System).Wait(); }); Assert.Equal(3, logs.Count()); } }
public void ReadLogTest() { var device = new DeviceData() { Serial = "169.254.109.177:5555", State = DeviceState.Online }; var responses = new AdbResponse[] { AdbResponse.OK, AdbResponse.OK }; var responseMessages = new string[] { }; var requests = new string[] { "host:transport:169.254.109.177:5555", "shell:logcat -B -b system" }; var receiver = new ConsoleOutputReceiver(); using (Stream stream = File.OpenRead("logcat.bin")) using (ShellStream shellStream = new ShellStream(stream, false)) { Logs.LogEntry[] logs = null; this.RunTest( responses, responseMessages, requests, shellStream, () => { logs = AdbClient.Instance.RunLogService(device, Logs.LogId.System).ToArray(); }); Assert.AreEqual(3, logs.Count()); } }
public void GetHashCodeTest() { AdbResponse first = new AdbResponse() { IOSuccess = false, Message = "Hi", Okay = false, Timeout = false }; AdbResponse second = new AdbResponse() { IOSuccess = false, Message = "Hi", Okay = false, Timeout = false }; Assert.AreEqual(first.GetHashCode(), second.GetHashCode()); }
public void RemoveReverseForwardTest() { var requests = new string[] { "host:transport:169.254.109.177:5555", "reverse:killforward:localabstract:test" }; var responses = new AdbResponse[] { AdbResponse.OK, AdbResponse.OK, }; this.RunTest( responses, NoResponseMessages, requests, () => this.TestClient.RemoveReverseForward(Device, "localabstract:test")); }
public void RemoveAllReversesTest() { var requests = new string[] { "host:transport:169.254.109.177:5555", "reverse:killforward-all" }; var responses = new AdbResponse[] { AdbResponse.OK, AdbResponse.OK, }; this.RunTest( responses, NoResponseMessages, requests, () => this.TestClient.RemoveAllReverseForwards(Device)); }
public void CreateDuplicateForwardTest() { var responses = new AdbResponse[] { AdbResponse.FromError("cannot rebind existing socket") }; var requests = new string[] { "host-serial:169.254.109.177:5555:forward:norebind:tcp:1;tcp:2" }; Assert.Throws <AdbException>(() => this.RunTest( responses, NoResponseMessages, requests, () => { this.TestClient.CreateForward(Device, "tcp:1", "tcp:2", false); })); }
public void ExecuteRemoteCommandTest() { var device = new DeviceData() { Serial = "169.254.109.177:5555", State = DeviceState.Online }; var responses = new AdbResponse[] { AdbResponse.OK, AdbResponse.OK }; var responseMessages = new string[] { }; var requests = new string[] { "host:transport:169.254.109.177:5555", "shell:echo Hello, World" }; byte[] streamData = Encoding.ASCII.GetBytes("Hello, World\r\n"); MemoryStream shellStream = new MemoryStream(streamData); var receiver = new ConsoleOutputReceiver(); this.RunTest( responses, responseMessages, requests, shellStream, () => { this.TestClient.ExecuteRemoteCommand("echo Hello, World", device, receiver); }); Assert.Equal("Hello, World\r\n", receiver.ToString(), ignoreLineEndingDifferences: true); }
public void EqualsTest() { AdbResponse first = new AdbResponse() { IOSuccess = false, Message = "Hi", Okay = false, Timeout = false }; AdbResponse second = new AdbResponse() { IOSuccess = true, Message = "Hi", Okay = false, Timeout = false }; Assert.IsFalse(first.Equals("some string")); Assert.IsFalse(first.Equals(second)); Assert.IsTrue(first.Equals(first)); }
/// <summary> /// Create and connect a new pass-through socket, from the host to a port on /// the device. /// </summary> /// <param name="adbSockAddr"> </param> /// <param name="device"> the device to connect to. Can be null in which case the connection will be /// to the first available device. </param> /// <param name="devicePort"> the port we're opening </param> /// <exception cref="TimeoutException"> in case of timeout on the connection. </exception> /// <exception cref="IOException"> in case of I/O error on the connection. </exception> /// <exception cref="AdbCommandRejectedException"> if adb rejects the command </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public static java.nio.channels.SocketChannel open(java.net.InetSocketAddress adbSockAddr, Device device, int devicePort) throws java.io.IOException, TimeoutException, AdbCommandRejectedException public static SocketChannel open(EndPoint adbSockAddr, Device device, int devicePort) { SocketChannel adbChan = SocketChannel.open(adbSockAddr); try { adbChan.socket().NoDelay = true; adbChan.configureBlocking(false); // if the device is not -1, then we first tell adb we're looking to // talk to a specific device setDevice(adbChan, device); var req = createAdbForwardRequest(null, devicePort); // Log.hexDump(req); write(adbChan, req); AdbResponse resp = readAdbResponse(adbChan, false); if (resp.okay == false) { throw new AdbCommandRejectedException(resp.message); } adbChan.configureBlocking(true); } catch (TimeoutException e) { adbChan.close(); throw e; } catch (IOException e) { adbChan.close(); throw e; } return(adbChan); }
public void ToStringTest() { Assert.AreEqual("OK", AdbResponse.OK.ToString()); Assert.AreEqual("Error: Huh?", AdbResponse.FromError("Huh?").ToString()); }
public void CreateDuplicateForwardTest() { var responses = new AdbResponse[] { AdbResponse.FromError("cannot rebind existing socket") }; var requests = new string[] { "host-serial:169.254.109.177:5555:forward:norebind:tcp:1;tcp:2" }; this.RunTest( responses, NoResponseMessages, requests, () => { AdbClient.Instance.CreateForward(Device, "tcp:1", "tcp:2", false); }); }
/// <summary> /// Reads the response from ADB after a command. </summary> /// <param name="readDiagString"> If true, we're expecting an OKAY response to be /// followed by a diagnostic string. Otherwise, we only expect the /// diagnostic string to follow a FAIL. </param> protected AdbResponse ReadAdbResponse(bool readDiagString) { var resp = new AdbResponse(); var reply = new byte[4]; Read(reply); if (IsOkay(reply)) { resp.Okay = true; } else { readDiagString = true; // look for a reason after the FAIL resp.Okay = false; } // not a loop -- use "while" so we can use "break" try { while (readDiagString) { int len; if (!TryReadHex4(out len)) break; var msg = new byte[len]; Read(msg); resp.Message = ReplyToString(msg); //Log.v("ddms", "Got reply '" + replyToString(reply) + "', diag='" + resp.message + "'"); break; } } catch (Exception) { // ignore those, since it's just reading the diagnose string, the response will // contain okay==false anyway. } return resp; }
/// <summary> /// Initializes a new instance of the <see cref="AdbException"/> class with the /// specified client error message and <see cref="AdbResponse"/> /// </summary> /// <param name="message"> /// The message that describes the error on the client side. /// </param> /// <param name="response"> /// The <see cref="AdbResponse"/> that was sent by adb. /// </param> public AdbException(string message, AdbResponse response) : base(message) { this.AdbError = response.Message; this.Response = response; }
public void RunCatLog(IPEndPoint address, IDevice device, string filePath) { if (device.IsOnline) { int num = 0x1400; Action action = null; Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); try { socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, new LingerOption(true, 0)); socket.ReceiveTimeout = -1; socket.ReceiveBufferSize = num + 1; socket.Blocking = true; socket.Connect(AndroidDebugBridge.SocketAddress); if (action == null) { action = delegate { if (socket != null) { socket.Close(); } }; } CancelAction = action; AdbHelper.Instance.SetDevice(socket, device); byte[] data = AdbHelper.Instance.FormAdbRequest(string.Format("shell:cat {0}", filePath)); //byte[] data = AdbHelper.Instance.FormAdbRequest(string.Format("log:{0}", filePath)); if (!AdbHelper.Instance.Write(socket, data)) { throw new AdbException("failed submitting shell command"); } AdbResponse response = AdbHelper.Instance.ReadAdbResponse(socket, false); if (!response.IOSuccess || !response.Okay) { throw new AdbException("sad result from adb: " + response.Message); } byte[] buffer = new byte[num + 1]; byte num2 = 0; while (device.IsOnline && !IsCancelled) { int num3 = socket.Receive(buffer); if (num3 > 0) { using (MemoryStream stream = new MemoryStream()) { for (int i = 0; i < num3; i++) { if ((((num3 > (i + 1)) && (buffer[i] == 13)) && (buffer[i + 1] == 10)) || ((num2 == 13) && (buffer[i] == 10))) { stream.WriteByte(10); i++; } else { stream.WriteByte(buffer[i]); } if (i == (num3 - 1)) { num2 = buffer[i]; } } this.ParseNewData(stream.ToArray(), 0, (int)stream.Length); } } } } catch (SocketException exception) { if (exception.SocketErrorCode != SocketError.ConnectionAborted) { Log.e("Socket error while receiving response", exception); } } finally { if (socket != null) { socket.Close(); socket.Dispose(); } } } }
/// <summary> /// Executes a shell command on the device and retrieve the output. The output is /// handed to <var>rcvr</var> as it arrives. /// </summary> /// <param name="adbSockAddr"> the <seealso cref="InetSocketAddress"/> to adb. </param> /// <param name="command"> the shell command to execute </param> /// <param name="device"> the <seealso cref="IDevice"/> on which to execute the command. </param> /// <param name="rcvr"> the <seealso cref="IShellOutputReceiver"/> that will receives the output of the shell /// command </param> /// <param name="maxTimeToOutputResponse"> max time between command output. If more time passes /// between command output, the method will throw /// <seealso cref="ShellCommandUnresponsiveException"/>. A value of 0 means the method will /// wait forever for command output and never throw. </param> /// <exception cref="TimeoutException"> in case of timeout on the connection when sending the command. </exception> /// <exception cref="AdbCommandRejectedException"> if adb rejects the command </exception> /// <exception cref="ShellCommandUnresponsiveException"> in case the shell command doesn't send any output /// for a period longer than <var>maxTimeToOutputResponse</var>. </exception> /// <exception cref="IOException"> in case of I/O error on the connection. /// </exception> /// <seealso cref= DdmPreferences#getTimeOut() </seealso> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: static void executeRemoteCommand(java.net.InetSocketAddress adbSockAddr, String command, IDevice device, IShellOutputReceiver rcvr, int maxTimeToOutputResponse) throws TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException, java.io.IOException internal static void executeRemoteCommand(EndPoint adbSockAddr, string command, IDevice device, IShellOutputReceiver rcvr, int maxTimeToOutputResponse) { Log.v("ddms", "execute: running " + command); SocketChannel adbChan = null; try { adbChan = SocketChannel.open(adbSockAddr); adbChan.configureBlocking(false); // if the device is not -1, then we first tell adb we're looking to // talk // to a specific device setDevice(adbChan, device); var request = formAdbRequest("shell:" + command); //$NON-NLS-1$ write(adbChan, request); AdbResponse resp = readAdbResponse(adbChan, false); // readDiagString if (resp.okay == false) { Log.e("ddms", "ADB rejected shell command (" + command + "): " + resp.message); throw new AdbCommandRejectedException(resp.message); } var data = new byte[16384]; ByteBuffer buf = ByteBuffer.wrap(data); int timeToResponseCount = 0; while (true) { int count; if (rcvr != null && rcvr.cancelled) { Log.v("ddms", "execute: cancelled"); break; } count = adbChan.read(buf); if (count < 0) { // we're at the end, we flush the output rcvr.flush(); Log.v("ddms", "execute '" + command + "' on '" + device + "' : EOF hit. Read: " + count); break; } else if (count == 0) { int wait = WAIT_TIME * 5; timeToResponseCount += wait; if (maxTimeToOutputResponse > 0 && timeToResponseCount > maxTimeToOutputResponse) { throw new ShellCommandUnresponsiveException(); } Thread.Sleep(wait); } else { // reset timeout timeToResponseCount = 0; // send data to receiver if present if (rcvr != null) { rcvr.addOutput(buf.array(), buf.arrayOffset(), buf.position); } buf.rewind(); } } } finally { if (adbChan != null) { adbChan.close(); } Log.v("ddms", "execute: returning"); } }
public void ExecuteRemoteCommandTest() { var device = new DeviceData() { Serial = "169.254.109.177:5555", State = DeviceState.Online }; var responses = new AdbResponse[] { AdbResponse.OK, AdbResponse.OK }; var responseMessages = new string[] { }; var requests = new string[] { "host:transport:169.254.109.177:5555", "shell:echo Hello, World" }; byte[] streamData = Encoding.ASCII.GetBytes("Hello, World\r\n"); MemoryStream shellStream = new MemoryStream(streamData); var receiver = new ConsoleOutputReceiver(); this.RunTest( responses, responseMessages, requests, shellStream, () => { AdbClient.Instance.ExecuteRemoteCommand("echo Hello, World", device, receiver); }); Assert.AreEqual("Hello, World\r\n", receiver.ToString()); }
public void ExecuteRemoteCommandUnresponsiveTest() { var device = new DeviceData() { Serial = "169.254.109.177:5555", State = DeviceState.Online }; var responses = new AdbResponse[] { AdbResponse.OK, AdbResponse.OK }; var responseMessages = new string[] { }; var requests = new string[] { "host:transport:169.254.109.177:5555", "shell:echo Hello, World" }; var receiver = new ConsoleOutputReceiver(); this.RunTest( responses, responseMessages, requests, null, () => { AdbClient.Instance.ExecuteRemoteCommand("echo Hello, World", device, receiver); }); }
/// <summary> /// Reads the response from ADB after a command. </summary> /// <param name="chan"> The socket channel that is connected to adb. </param> /// <param name="readDiagString"> If true, we're expecting an OKAY response to be /// followed by a diagnostic string. Otherwise, we only expect the /// diagnostic string to follow a FAIL. </param> /// <exception cref="TimeoutException"> in case of timeout on the connection. </exception> /// <exception cref="IOException"> in case of I/O error on the connection. </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: static AdbResponse readAdbResponse(java.nio.channels.SocketChannel chan, boolean readDiagString) throws TimeoutException, java.io.IOException internal static AdbResponse readAdbResponse(SocketChannel chan, bool readDiagString) { AdbResponse resp = new AdbResponse(); var reply = new byte[4]; read(chan, reply); if (isOkay(reply)) { resp.okay = true; } else { readDiagString = true; // look for a reason after the FAIL resp.okay = false; } // not a loop -- use "while" so we can use "break" try { while (readDiagString) { // length string is in next 4 bytes var lenBuf = new byte[4]; read(chan, lenBuf); string lenStr = replyToString(lenBuf); int len; try { len = Convert.ToInt32(lenStr, 16); } catch (SystemException) { Log.w("ddms", "Expected digits, got '" + lenStr + "': " + lenBuf[0] + " " + lenBuf[1] + " " + lenBuf[2] + " " + lenBuf[3]); Log.w("ddms", "reply was " + replyToString(reply)); break; } var msg = new byte[len]; read(chan, msg); resp.message = replyToString(msg); Log.v("ddms", "Got reply '" + replyToString(reply) + "', diag='" + resp.message + "'"); break; } } catch (Exception) { // ignore those, since it's just reading the diagnose string, the response will // contain okay==false anyway. } return resp; }
/// <summary> /// Retrieve the frame buffer from the device. </summary> /// <exception cref="TimeoutException"> in case of timeout on the connection. </exception> /// <exception cref="AdbCommandRejectedException"> if adb rejects the command </exception> /// <exception cref="IOException"> in case of I/O error on the connection. </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: static RawImage getFrameBuffer(java.net.InetSocketAddress adbSockAddr, Device device) throws TimeoutException, AdbCommandRejectedException, java.io.IOException internal static RawImage getFrameBuffer(EndPoint adbSockAddr, Device device) { RawImage imageParams = new RawImage(); var request = formAdbRequest("framebuffer:"); //$NON-NLS-1$ byte[] nudge = { 0 }; byte[] reply; SocketChannel adbChan = null; try { adbChan = SocketChannel.open(adbSockAddr); adbChan.configureBlocking(false); // if the device is not -1, then we first tell adb we're looking to talk // to a specific device setDevice(adbChan, device); write(adbChan, request); AdbResponse resp = readAdbResponse(adbChan, false); // readDiagString if (resp.okay == false) { throw new AdbCommandRejectedException(resp.message); } // first the protocol version. reply = new byte[4]; read(adbChan, reply); ByteBuffer buf = ByteBuffer.wrap(reply); buf.order = ByteOrder.LITTLE_ENDIAN; int version = buf.getInt(); // get the header size (this is a count of int) int headerSize = RawImage.getHeaderSize(version); // read the header reply = new byte[headerSize * 4]; read(adbChan, reply); buf = ByteBuffer.wrap(reply); buf.order = ByteOrder.LITTLE_ENDIAN; // fill the RawImage with the header if (imageParams.readHeader(version, buf) == false) { Log.e("Screenshot", "Unsupported protocol: " + version); return(null); } Log.d("ddms", "image params: bpp=" + imageParams.bpp + ", size=" + imageParams.size + ", width=" + imageParams.width + ", height=" + imageParams.height); write(adbChan, nudge); reply = new byte[imageParams.size]; read(adbChan, reply); imageParams.data = reply; } finally { if (adbChan != null) { adbChan.close(); } } return(imageParams); }