/// <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(); } } }
/// <summary> /// Reads from the socket until the array is filled, the optional length /// is reached, or no more data is coming (because the socket closed or the /// timeout expired). After "timeout" milliseconds since the /// previous successful read, this will return whether or not new data has /// been found. /// </summary> /// <param name="chan"> the opened socket to read from. It must be in non-blocking /// mode for timeouts to work </param> /// <param name="data"> the buffer to store the read data into. </param> /// <param name="length"> the length to read or -1 to fill the data buffer completely </param> /// <param name="timeout"> The timeout value. A timeout of zero means "wait forever". </param> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: static void read(java.nio.channels.SocketChannel chan, byte[] data, int length, int timeout) throws TimeoutException, java.io.IOException internal static void read(SocketChannel chan, byte[] data, int length, int timeout) { ByteBuffer buf = ByteBuffer.wrap(data, 0, length != -1 ? length : data.Length); int numWaits = 0; while (buf.position != buf.limit) { int count; count = chan.read(buf); if (count < 0) { Log.d("ddms", "read: channel EOF"); throw new IOException("EOF"); } else if (count == 0) { // TODO: need more accurate timeout? if (timeout != 0 && numWaits * WAIT_TIME > timeout) { Log.d("ddms", "read: timeout"); throw new TimeoutException(); } // non-blocking spin Thread.Sleep(WAIT_TIME); numWaits++; } else { numWaits = 0; } } }
/// <summary> /// Fills a buffer from a socket. </summary> /// <param name="socket"> </param> /// <param name="buffer"> </param> /// <returns> the content of the buffer as a string, or null if it failed to convert the buffer. </returns> /// <exception cref="IOException"> </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private String read(java.nio.channels.SocketChannel socket, byte[] buffer) throws java.io.IOException private string read(SocketChannel socket, byte[] buffer) { ByteBuffer buf = ByteBuffer.wrap(buffer, 0, buffer.Length); while (buf.position != buf.limit) { int count; count = socket.read(buf); if (count < 0) { throw new IOException("EOF"); } } try { return(buffer.getString(0, buf.position, AdbHelper.DEFAULT_ENCODING)); } catch (ArgumentException) { // we'll return null below. } return(null); }
// TODO: ?? add a finalizer that verifies the channel was closed /// <summary> /// Read data from our channel. /// /// This is called when data is known to be available, and we don't yet /// have a full packet in the buffer. If the buffer is at capacity, /// expand it. /// </summary> internal void read() { int count; if (mReadBuffer.position == mReadBuffer.capacity) { if (mReadBuffer.capacity * 2 > MAX_BUF_SIZE) { throw new OverflowException(); } Log.d("ddms", "Expanding read buffer to " + mReadBuffer.capacity * 2); ByteBuffer newBuffer = ByteBuffer.allocate(mReadBuffer.capacity * 2); mReadBuffer.position = 0; newBuffer.put(mReadBuffer); // leaves "position" at end mReadBuffer = newBuffer; } count = mChannel.read(mReadBuffer); Log.v("ddms", "Read " + count + " bytes from " + this); if (count < 0) { throw new IOException("read failed"); } }
/// <summary> /// Read data from our channel. /// /// This is called when data is known to be available, and we don't yet /// have a full packet in the buffer. If the buffer is at capacity, /// expand it. /// </summary> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: void read() throws java.io.IOException, java.nio.BufferOverflowException internal virtual void read() { int count; if (mReadBuffer.position == mReadBuffer.capacity) { if (mReadBuffer.capacity * 2 > MAX_BUF_SIZE) { Log.e("ddms", "Exceeded MAX_BUF_SIZE!"); throw new OverflowException(); } Log.d("ddms", "Expanding read buffer to " + mReadBuffer.capacity * 2); ByteBuffer newBuffer = ByteBuffer.allocate(mReadBuffer.capacity * 2); // copy entire buffer to new buffer mReadBuffer.position = (0); newBuffer.put(mReadBuffer); // leaves "position" at end of copied mReadBuffer = newBuffer; } count = mChan.read(mReadBuffer); if (count < 0) { throw new IOException("read failed"); } if (Log.Config.LOGV) { Log.v("ddms", "Read " + count + " bytes from " + this); } //Log.hexDump("ddms", Log.DEBUG, mReadBuffer.array(), // mReadBuffer.arrayOffset(), mReadBuffer.position()); }
/// <summary> /// Reads line from the console socket. This call is blocking until we read the lines: /// <ul> /// <li>OK\r\n</li> /// <li>KO<msg>\r\n</li> /// </ul> </summary> /// <returns> the array of strings read from the emulator. </returns> private string[] readLines() { try { ByteBuffer buf = ByteBuffer.wrap(mBuffer, 0, mBuffer.Length); int numWaits = 0; bool stop = false; while (buf.position != buf.limit && stop == false) { int count; count = mSocketChannel.read(buf); if (count < 0) { return null; } else if (count == 0) { if (numWaits * WAIT_TIME > STD_TIMEOUT) { return null; } // non-blocking spin try { Thread.Sleep(WAIT_TIME); } catch (ThreadInterruptedException) { } numWaits++; } else { numWaits = 0; } // check the last few char aren't OK. For a valid message to test // we need at least 4 bytes (OK/KO + \r\n) if (buf.position >= 4) { int pos = buf.position; if (endsWithOK(pos) || lastLineIsKO(pos)) { stop = true; } } } string msg = mBuffer.getString(0, buf.position, DEFAULT_ENCODING); return StringHelperClass.StringSplit(msg, "\r\n", true); //$NON-NLS-1$ } catch (IOException) { return null; } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public byte[] read() throws java.io.IOException public virtual sbyte[] read() { sbyte[] buffer = new sbyte[BUFFER_SIZE]; int Length = socketChannel.read(ByteBuffer.wrap(buffer)); if (Length <= 0) { return(null); } sbyte[] readBuffer = new sbyte[Length]; Array.Copy(buffer, 0, readBuffer, 0, Length); return(readBuffer); }
/// <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"); } }