public override int Read(byte[] dest, int timeoutMillis)
            {
                if (ENABLE_ASYNC_READS)
                {
                    var request = new UsbRequest();
                    try
                    {
                        request.Initialize(mConnection, mReadEndpoint);
                        var buf = ByteBuffer.Wrap(dest);
                        if (!request.Queue(buf, dest.Length))
                        {
                            throw new IOException("Error queuing request");
                        }

                        var response = mConnection.RequestWait();
                        if (response == null)
                        {
                            throw new IOException("Null response");
                        }

                        var nread = buf.Position();
                        return(nread > 0 ? nread : 0);
                    }
                    finally
                    {
                        request.Close();
                    }
                }

                int numBytesRead;

                lock (mReadBufferLock)
                {
                    var readAmt = Math.Min(dest.Length, mReadBuffer.Length);
                    numBytesRead = mConnection.BulkTransfer(mReadEndpoint,
                                                            mReadBuffer,
                                                            readAmt,
                                                            timeoutMillis);
                    if (numBytesRead < 0)
                    {
                        // This sucks: we get -1 on timeout, not 0 as preferred.
                        // We *should* use UsbRequest, except it has a bug/api oversight
                        // where there is no way to determine the number of bytes read
                        // in response :\ -- http://b.android.com/28023
                        if (timeoutMillis == int.MaxValue)
                        {
                            // Hack: Special case "~infinite timeout" as an error.
                            return(-1);
                        }

                        return(0);
                    }

                    Array.Copy(mReadBuffer, 0, dest, 0, numBytesRead);
                }

                return(numBytesRead);
            }
        public override int Read(byte[] dest, int timeoutMilliseconds)
        {
            if (_enableAsyncReads)
            {
                var request = new UsbRequest();
                try
                {
                    request.Initialize(_connection, _readEndpoint);

                    var buf = ByteBuffer.Wrap(dest);
                    if (!request.Queue(buf, dest.Length)) //TODO: Must fix this
                    {
                        throw new UsbSerialException("Error queueing request.");
                    }

                    UsbRequest response = _connection.RequestWait();
                    if (response == null)
                    {
                        throw new UsbSerialException("Null response");
                    }

                    int nread = buf.Position();
                    if (nread > 0)
                    {
                        return(nread);
                    }
                    else
                    {
                        return(0);
                    }
                }
                finally
                {
                    request.Close();
                }
            }

            int numBytesRead;

            lock (_readBufferLock)
            {
                int readAmt = Math.Min(dest.Length, _readBuffer.Length);
                numBytesRead = _connection.BulkTransfer(_readEndpoint, _readBuffer, readAmt, timeoutMilliseconds);
                if (numBytesRead < 0)
                {
                    if (timeoutMilliseconds == int.MaxValue)
                    {
                        return(-1);
                    }
                    return(0);
                }
                Array.Copy(_readBuffer, 0, dest, 0, numBytesRead);
            }
            return(numBytesRead);
        }
Beispiel #3
0
        protected override int ReadInternal()
        {
            if (EnableAsyncReads)
            {
                UsbRequest request = new UsbRequest();
                try
                {
                    request.Initialize(Connection, ReadEndpoint);
                    ByteBuffer buf = ByteBuffer.Wrap(TempReadBuffer);
                    if (!request.Queue(buf, TempReadBuffer.Length))
                    {
                        throw new IOException("Error queueing request.");
                    }

                    UsbRequest response = Connection.RequestWait();
                    if (response == null)
                    {
                        throw new IOException("Null response");
                    }

                    int nread = buf.Position();
                    if (nread > 0)
                    {
                        //Log.Debug(Tag, HexDump.DumpHexString(TempReadBuffer, 0, Math.Min(32, TempReadBuffer.Length)));
                        return(nread);
                    }
                    else
                    {
                        return(0);
                    }
                }
                finally
                {
                    request.Close();
                }
            }

            numberOfBytesRead = Connection.BulkTransfer(ReadEndpoint, TempReadBuffer, TempReadBuffer.Length, DEFAULT_READ_TIMEOUT_MILLISEC);
            //Log.Info(Tag, "Data Length : " + DateTime.Now.ToString("HH:mm:ss.fff") + ":" + numberOfBytesRead.ToString() + "\n");
            if (numberOfBytesRead < 0)
            {
                // This sucks: we get -1 on timeout, not 0 as preferred.
                // We *should* use UsbRequest, except it has a bug/api oversight
                // where there is no way to determine the number of bytes read
                // in response :\ -- http://b.android.com/28023
                if (DEFAULT_READ_TIMEOUT_MILLISEC == int.MaxValue)
                {
                    // Hack: Special case "~infinite timeout" as an error.
                    return(-1);
                }
                return(0);
            }
            return(numberOfBytesRead);
        }
Beispiel #4
0
            public override int Read(byte[] dest, int timeoutMillis)
            {
                if (mEnableAsyncReads)
                {
                    UsbRequest request = new UsbRequest();
                    try
                    {
                        request.Initialize(mConnection, mReadEndpoint);

                        // CJM: Xamarin bug:  ByteBuffer.Wrap is supposed to be a two way update
                        // Changes made to one buffer should reflect in the other.  It's not working
                        // As a work around, I added a new method as an extension that uses JNI to turn
                        // a new byte[] array.  I then used BlockCopy to copy the bytes back the original array
                        // see https://forums.xamarin.com/discussion/comment/238396/#Comment_238396
                        //
                        // Old work around:
                        // as a work around, we populate dest with a call to buf.Get()
                        // see https://bugzilla.xamarin.com/show_bug.cgi?id=20772
                        // and https://bugzilla.xamarin.com/show_bug.cgi?id=31260

                        ByteBuffer buf = ByteBuffer.Wrap(dest);
                        if (!request.Queue(buf, dest.Length))
                        {
                            throw new IOException("Error queueing request.");
                        }

                        UsbRequest response = mConnection.RequestWait();
                        if (response == null)
                        {
                            throw new IOException("Null response");
                        }

                        int nread = buf.Position();
                        if (nread > 0)
                        {
                            // CJM: This differs from the Java implementation.  The dest buffer was
                            // not getting the data back.

                            // 1st work around, no longer used
                            //buf.Rewind();
                            //buf.Get(dest, 0, dest.Length);

                            System.Buffer.BlockCopy(buf.ToByteArray(), 0, dest, 0, dest.Length);

                            Log.Debug(TAG, HexDump.DumpHexString(dest, 0, Math.Min(32, dest.Length)));
                            return(nread);
                        }
                        else
                        {
                            return(0);
                        }
                    }
                    finally
                    {
                        request.Close();
                    }
                }

                int numBytesRead;

                lock (mReadBufferLock)
                {
                    int readAmt = Math.Min(dest.Length, mReadBuffer.Length);
                    numBytesRead = mConnection.BulkTransfer(mReadEndpoint, mReadBuffer, readAmt,
                                                            timeoutMillis);
                    if (numBytesRead < 0)
                    {
                        // This sucks: we get -1 on timeout, not 0 as preferred.
                        // We *should* use UsbRequest, except it has a bug/api oversight
                        // where there is no way to determine the number of bytes read
                        // in response :\ -- http://b.android.com/28023
                        if (timeoutMillis == Integer.MaxValue)
                        {
                            // Hack: Special case "~infinite timeout" as an error.
                            return(-1);
                        }
                        return(0);
                    }
                    System.Buffer.BlockCopy(mReadBuffer, 0, dest, 0, numBytesRead);
                }
                return(numBytesRead);
            }
Beispiel #5
0
        protected override int ReadInternal(byte[] dest, int timeoutMillis)
        {
            if (mEnableAsyncReads)
            {
                UsbRequest request = new UsbRequest();
                try
                {
                    request.Initialize(Connection, mReadEndpoint);
                    ByteBuffer buf = ByteBuffer.Wrap(dest);
                    if (!request.Queue(buf, dest.Length))
                    {
                        throw new IOException("Error queueing request.");
                    }

                    UsbRequest response = Connection.RequestWait();
                    if (response == null)
                    {
                        throw new IOException("Null response");
                    }

                    int nread = buf.Position();
                    if (nread > 0)
                    {
                        //Log.Debug(Tag, HexDump.DumpHexString(dest, 0, Math.Min(32, dest.Length)));
                        return(nread);
                    }
                    else
                    {
                        return(0);
                    }
                }
                finally
                {
                    request.Close();
                }
            }

            int numBytesRead;

            lock (mInternalReadBufferLock)
            {
                int readAmt = Math.Min(dest.Length, mInternalReadBuffer.Length);
                numBytesRead = Connection.BulkTransfer(mReadEndpoint, mInternalReadBuffer, readAmt,
                                                       timeoutMillis);
                if (numBytesRead < 0)
                {
                    // This sucks: we get -1 on timeout, not 0 as preferred.
                    // We *should* use UsbRequest, except it has a bug/api oversight
                    // where there is no way to determine the number of bytes read
                    // in response :\ -- http://b.android.com/28023
                    if (timeoutMillis == int.MaxValue)
                    {
                        // Hack: Special case "~infinite timeout" as an error.
                        return(-1);
                    }
                    return(0);
                }
                Array.Copy(mInternalReadBuffer, 0, dest, 0, numBytesRead);
            }
            return(numBytesRead);
        }