Merge pull request #75 from felHR85/sync_example

Synchronous example and bug solved

build.gradle

@@ -3,7 +3,7 @@ buildscript {
         jcenter()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:2.1.2'
+        classpath 'com.android.tools.build:gradle:2.1.3'
     }
 }
 

examplesync/.gitignore

@@ -0,0 +1 @@
+/build

examplesync/build.gradle

@@ -0,0 +1,29 @@
+apply plugin: 'com.android.application'
+
+android {
+
+    compileSdkVersion Integer.parseInt(project.ANDROID_BUILD_SDK_VERSION)
+    buildToolsVersion project.ANDROID_BUILD_TOOLS_VERSION
+
+    defaultConfig {
+        applicationId "com.felhr.serialportexamplesync"
+        minSdkVersion Integer.parseInt(project.ANDROID_BUILD_MIN_SDK_VERSION)
+        targetSdkVersion Integer.parseInt(project.ANDROID_BUILD_TARGET_SDK_VERSION)
+        versionName project.VERSION_NAME
+        versionCode Integer.parseInt(project.VERSION_CODE)
+    }
+
+    compileOptions {
+        encoding "UTF-8"
+        sourceCompatibility JavaVersion.VERSION_1_7
+        targetCompatibility JavaVersion.VERSION_1_7
+    }
+}
+
+dependencies {
+    compile 'com.android.support:support-v4:23.1.1'
+    compile 'com.android.support:appcompat-v7:23.1.1'
+    compile 'com.android.support:design:23.1.1'
+
+    compile project(':usbserial')
+}

examplesync/proguard-rules.pro

@@ -0,0 +1,17 @@
+# Add project specific ProGuard rules here.
+# By default, the flags in this file are appended to flags specified
+# in /Applications/AndroidSDK/sdk/tools/proguard/proguard-android.txt
+# You can edit the include path and order by changing the proguardFiles
+# directive in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# Add any project specific keep options here:
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}

examplesync/src/main/AndroidManifest.xml

@@ -0,0 +1,30 @@
+<manifest package="com.felhr.serialportexamplesync"
+          xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <uses-feature android:name="android.hardware.usb.host"
+                  android:required="true"/>
+
+    <application
+        android:allowBackup="true"
+        android:icon="@mipmap/ic_launcher"
+        android:label="@string/app_name"
+        android:supportsRtl="true"
+        android:theme="@style/AppTheme">
+
+        <activity
+            android:name=".MainActivity"
+            android:label="@string/app_name">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN"/>
+
+                <category android:name="android.intent.category.LAUNCHER"/>
+            </intent-filter>
+        </activity>
+        <service
+            android:name="com.felhr.serialportexamplesync.UsbService"
+            android:enabled="true">
+        </service>
+
+    </application>
+
+</manifest>

examplesync/src/main/java/com/felhr/serialportexamplesync/MainActivity.java

@@ -0,0 +1,196 @@
+package com.felhr.serialportexamplesync;
+
+import android.content.BroadcastReceiver;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.ServiceConnection;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.IBinder;
+import android.os.Message;
+import android.support.v7.app.AppCompatActivity;
+import android.view.View;
+import android.widget.Button;
+import android.widget.CheckBox;
+import android.widget.CompoundButton;
+import android.widget.EditText;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import java.lang.ref.WeakReference;
+import java.util.Set;
+
+public class MainActivity extends AppCompatActivity {
+
+    /*
+     * Notifications from UsbService will be received here.
+     */
+    private final BroadcastReceiver mUsbReceiver = new BroadcastReceiver() {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            switch (intent.getAction()) {
+                case UsbService.ACTION_USB_PERMISSION_GRANTED: // USB PERMISSION GRANTED
+                    Toast.makeText(context, "USB Ready", Toast.LENGTH_SHORT).show();
+                    break;
+                case UsbService.ACTION_USB_PERMISSION_NOT_GRANTED: // USB PERMISSION NOT GRANTED
+                    Toast.makeText(context, "USB Permission not granted", Toast.LENGTH_SHORT).show();
+                    break;
+                case UsbService.ACTION_NO_USB: // NO USB CONNECTED
+                    Toast.makeText(context, "No USB connected", Toast.LENGTH_SHORT).show();
+                    break;
+                case UsbService.ACTION_USB_DISCONNECTED: // USB DISCONNECTED
+                    Toast.makeText(context, "USB disconnected", Toast.LENGTH_SHORT).show();
+                    break;
+                case UsbService.ACTION_USB_NOT_SUPPORTED: // USB NOT SUPPORTED
+                    Toast.makeText(context, "USB device not supported", Toast.LENGTH_SHORT).show();
+                    break;
+            }
+        }
+    };
+    private UsbService usbService;
+    private TextView display;
+    private EditText editText;
+    private CheckBox box9600, box38400;
+    private MyHandler mHandler;
+    private final ServiceConnection usbConnection = new ServiceConnection() {
+        @Override
+        public void onServiceConnected(ComponentName arg0, IBinder arg1) {
+            usbService = ((UsbService.UsbBinder) arg1).getService();
+            usbService.setHandler(mHandler);
+        }
+
+        @Override
+        public void onServiceDisconnected(ComponentName arg0) {
+            usbService = null;
+        }
+    };
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_main);
+
+        mHandler = new MyHandler(this);
+
+        display = (TextView) findViewById(R.id.textView1);
+        editText = (EditText) findViewById(R.id.editText1);
+        Button sendButton = (Button) findViewById(R.id.buttonSend);
+        sendButton.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                if (!editText.getText().toString().equals("")) {
+                    String data = editText.getText().toString();
+                    if (usbService != null) { // if UsbService was correctly binded, Send data
+                        usbService.write(data.getBytes());
+                    }
+                }
+            }
+        });
+
+        box9600 = (CheckBox) findViewById(R.id.checkBox);
+        box9600.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
+            @Override
+            public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
+                if(box9600.isChecked())
+                    box38400.setChecked(false);
+                else
+                    box38400.setChecked(true);
+            }
+        });
+
+        box38400 = (CheckBox) findViewById(R.id.checkBox2);
+        box38400.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
+            @Override
+            public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
+                if(box38400.isChecked())
+                    box9600.setChecked(false);
+                else
+                    box9600.setChecked(true);
+            }
+        });
+
+        Button baudrateButton = (Button) findViewById(R.id.buttonBaudrate);
+        baudrateButton.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                if(box9600.isChecked())
+                    usbService.changeBaudRate(9600);
+                else
+                    usbService.changeBaudRate(38400);
+            }
+        });
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        setFilters();  // Start listening notifications from UsbService
+        startService(UsbService.class, usbConnection, null); // Start UsbService(if it was not started before) and Bind it
+    }
+
+    @Override
+    public void onPause() {
+        super.onPause();
+        unregisterReceiver(mUsbReceiver);
+        unbindService(usbConnection);
+    }
+
+    private void startService(Class<?> service, ServiceConnection serviceConnection, Bundle extras) {
+        if (!UsbService.SERVICE_CONNECTED) {
+            Intent startService = new Intent(this, service);
+            if (extras != null && !extras.isEmpty()) {
+                Set<String> keys = extras.keySet();
+                for (String key : keys) {
+                    String extra = extras.getString(key);
+                    startService.putExtra(key, extra);
+                }
+            }
+            startService(startService);
+        }
+        Intent bindingIntent = new Intent(this, service);
+        bindService(bindingIntent, serviceConnection, Context.BIND_AUTO_CREATE);
+    }
+
+    private void setFilters() {
+        IntentFilter filter = new IntentFilter();
+        filter.addAction(UsbService.ACTION_USB_PERMISSION_GRANTED);
+        filter.addAction(UsbService.ACTION_NO_USB);
+        filter.addAction(UsbService.ACTION_USB_DISCONNECTED);
+        filter.addAction(UsbService.ACTION_USB_NOT_SUPPORTED);
+        filter.addAction(UsbService.ACTION_USB_PERMISSION_NOT_GRANTED);
+        registerReceiver(mUsbReceiver, filter);
+    }
+
+    /*
+     * This handler will be passed to UsbService. Data received from serial port is displayed through this handler
+     */
+    private static class MyHandler extends Handler {
+        private final WeakReference<MainActivity> mActivity;
+
+        public MyHandler(MainActivity activity) {
+            mActivity = new WeakReference<>(activity);
+        }
+
+        @Override
+        public void handleMessage(Message msg) {
+            switch (msg.what) {
+                case UsbService.MESSAGE_FROM_SERIAL_PORT:
+                    String data = (String) msg.obj;
+                    mActivity.get().display.append(data);
+                    break;
+                case UsbService.CTS_CHANGE:
+                    Toast.makeText(mActivity.get(), "CTS_CHANGE",Toast.LENGTH_LONG).show();
+                    break;
+                case UsbService.DSR_CHANGE:
+                    Toast.makeText(mActivity.get(), "DSR_CHANGE",Toast.LENGTH_LONG).show();
+                    break;
+                case UsbService.SYNC_READ:
+                    String buffer = (String) msg.obj;
+                    mActivity.get().display.append(buffer);
+                    break;
+            }
+        }
+    }
+}

examplesync/src/main/java/com/felhr/serialportexamplesync/UsbService.java

@@ -0,0 +1,310 @@
+package com.felhr.serialportexamplesync;
+
+import android.app.PendingIntent;
+import android.app.Service;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.hardware.usb.UsbDevice;
+import android.hardware.usb.UsbDeviceConnection;
+import android.hardware.usb.UsbManager;
+import android.os.Binder;
+import android.os.Handler;
+import android.os.IBinder;
+
+import com.felhr.usbserial.CDCSerialDevice;
+import com.felhr.usbserial.UsbSerialDevice;
+import com.felhr.usbserial.UsbSerialInterface;
+
+import java.io.UnsupportedEncodingException;
+import java.util.HashMap;
+import java.util.Map;
+
+public class UsbService extends Service {
+
+    public static final String ACTION_USB_READY = "com.felhr.connectivityservices.USB_READY";
+    public static final String ACTION_USB_ATTACHED = "android.hardware.usb.action.USB_DEVICE_ATTACHED";
+    public static final String ACTION_USB_DETACHED = "android.hardware.usb.action.USB_DEVICE_DETACHED";
+    public static final String ACTION_USB_NOT_SUPPORTED = "com.felhr.usbservice.USB_NOT_SUPPORTED";
+    public static final String ACTION_NO_USB = "com.felhr.usbservice.NO_USB";
+    public static final String ACTION_USB_PERMISSION_GRANTED = "com.felhr.usbservice.USB_PERMISSION_GRANTED";
+    public static final String ACTION_USB_PERMISSION_NOT_GRANTED = "com.felhr.usbservice.USB_PERMISSION_NOT_GRANTED";
+    public static final String ACTION_USB_DISCONNECTED = "com.felhr.usbservice.USB_DISCONNECTED";
+    public static final String ACTION_CDC_DRIVER_NOT_WORKING = "com.felhr.connectivityservices.ACTION_CDC_DRIVER_NOT_WORKING";
+    public static final String ACTION_USB_DEVICE_NOT_WORKING = "com.felhr.connectivityservices.ACTION_USB_DEVICE_NOT_WORKING";
+    public static final int MESSAGE_FROM_SERIAL_PORT = 0;
+    public static final int CTS_CHANGE = 1;
+    public static final int DSR_CHANGE = 2;
+    public static final int SYNC_READ = 3;
+    private static final String ACTION_USB_PERMISSION = "com.android.example.USB_PERMISSION";
+    private static final int BAUD_RATE = 9600; // BaudRate. Change this value if you need
+    public static boolean SERVICE_CONNECTED = false;
+
+    private IBinder binder = new UsbBinder();
+
+    private Context context;
+    private Handler mHandler;
+    private UsbManager usbManager;
+    private UsbDevice device;
+    private UsbDeviceConnection connection;
+    private UsbSerialDevice serialPort;
+
+    private boolean serialPortConnected;
+    /*
+     *  Data received from serial port will be received here. Just populate onReceivedData with your code
+     *  In this particular example. byte stream is converted to String and send to UI thread to
+     *  be treated there.
+     */
+    private UsbSerialInterface.UsbReadCallback mCallback = new UsbSerialInterface.UsbReadCallback() {
+        @Override
+        public void onReceivedData(byte[] arg0) {
+            try {
+                String data = new String(arg0, "UTF-8");
+                if (mHandler != null)
+                    mHandler.obtainMessage(MESSAGE_FROM_SERIAL_PORT, data).sendToTarget();
+            } catch (UnsupportedEncodingException e) {
+                e.printStackTrace();
+            }
+        }
+    };
+
+    /*
+     * State changes in the CTS line will be received here
+     */
+    private UsbSerialInterface.UsbCTSCallback ctsCallback = new UsbSerialInterface.UsbCTSCallback() {
+        @Override
+        public void onCTSChanged(boolean state) {
+            if(mHandler != null)
+                mHandler.obtainMessage(CTS_CHANGE).sendToTarget();
+        }
+    };
+
+    /*
+     * State changes in the DSR line will be received here
+     */
+    private UsbSerialInterface.UsbDSRCallback dsrCallback = new UsbSerialInterface.UsbDSRCallback() {
+        @Override
+        public void onDSRChanged(boolean state) {
+            if(mHandler != null)
+                mHandler.obtainMessage(DSR_CHANGE).sendToTarget();
+        }
+    };
+    /*
+     * Different notifications from OS will be received here (USB attached, detached, permission responses...)
+     * About BroadcastReceiver: http://developer.android.com/reference/android/content/BroadcastReceiver.html
+     */
+    private final BroadcastReceiver usbReceiver = new BroadcastReceiver() {
+        @Override
+        public void onReceive(Context arg0, Intent arg1) {
+            if (arg1.getAction().equals(ACTION_USB_PERMISSION)) {
+                boolean granted = arg1.getExtras().getBoolean(UsbManager.EXTRA_PERMISSION_GRANTED);
+                if (granted) // User accepted our USB connection. Try to open the device as a serial port
+                {
+                    Intent intent = new Intent(ACTION_USB_PERMISSION_GRANTED);
+                    arg0.sendBroadcast(intent);
+                    connection = usbManager.openDevice(device);
+                    new ConnectionThread().start();
+                } else // User not accepted our USB connection. Send an Intent to the Main Activity
+                {
+                    Intent intent = new Intent(ACTION_USB_PERMISSION_NOT_GRANTED);
+                    arg0.sendBroadcast(intent);
+                }
+            } else if (arg1.getAction().equals(ACTION_USB_ATTACHED)) {
+                if (!serialPortConnected)
+                    findSerialPortDevice(); // A USB device has been attached. Try to open it as a Serial port
+            } else if (arg1.getAction().equals(ACTION_USB_DETACHED)) {
+                // Usb device was disconnected. send an intent to the Main Activity
+                Intent intent = new Intent(ACTION_USB_DISCONNECTED);
+                arg0.sendBroadcast(intent);
+                if (serialPortConnected) {
+                    serialPort.syncClose();
+                }
+                serialPortConnected = false;
+            }
+        }
+    };
+
+    /*
+     * onCreate will be executed when service is started. It configures an IntentFilter to listen for
+     * incoming Intents (USB ATTACHED, USB DETACHED...) and it tries to open a serial port.
+     */
+    @Override
+    public void onCreate() {
+        this.context = this;
+        serialPortConnected = false;
+        UsbService.SERVICE_CONNECTED = true;
+        setFilter();
+        usbManager = (UsbManager) getSystemService(Context.USB_SERVICE);
+        findSerialPortDevice();
+    }
+
+    /* MUST READ about services
+     * http://developer.android.com/guide/components/services.html
+     * http://developer.android.com/guide/components/bound-services.html
+     */
+    @Override
+    public IBinder onBind(Intent intent) {
+        return binder;
+    }
+
+    @Override
+    public int onStartCommand(Intent intent, int flags, int startId) {
+        return Service.START_NOT_STICKY;
+    }
+
+    @Override
+    public void onDestroy() {
+        super.onDestroy();
+        UsbService.SERVICE_CONNECTED = false;
+    }
+
+    /*
+     * This function will be called from MainActivity to write data through Serial Port
+     */
+    public void write(byte[] data) {
+        if (serialPort != null)
+            serialPort.syncWrite(data, 0);
+    }
+
+    /*
+     * This function will be called from MainActivity to change baud rate
+     */
+
+    public void changeBaudRate(int baudRate){
+        if(serialPort != null)
+            serialPort.setBaudRate(baudRate);
+    }
+
+    public void setHandler(Handler mHandler) {
+        this.mHandler = mHandler;
+    }
+
+    private void findSerialPortDevice() {
+        // This snippet will try to open the first encountered usb device connected, excluding usb root hubs
+        HashMap<String, UsbDevice> usbDevices = usbManager.getDeviceList();
+        if (!usbDevices.isEmpty()) {
+            boolean keep = true;
+            for (Map.Entry<String, UsbDevice> entry : usbDevices.entrySet()) {
+                device = entry.getValue();
+                int deviceVID = device.getVendorId();
+                int devicePID = device.getProductId();
+
+                if (deviceVID != 0x1d6b && (devicePID != 0x0001 && devicePID != 0x0002 && devicePID != 0x0003)) {
+                    // There is a device connected to our Android device. Try to open it as a Serial Port.
+                    requestUserPermission();
+                    keep = false;
+                } else {
+                    connection = null;
+                    device = null;
+                }
+
+                if (!keep)
+                    break;
+            }
+            if (!keep) {
+                // There is no USB devices connected (but usb host were listed). Send an intent to MainActivity.
+                Intent intent = new Intent(ACTION_NO_USB);
+                sendBroadcast(intent);
+            }
+        } else {
+            // There is no USB devices connected. Send an intent to MainActivity
+            Intent intent = new Intent(ACTION_NO_USB);
+            sendBroadcast(intent);
+        }
+    }
+
+    private void setFilter() {
+        IntentFilter filter = new IntentFilter();
+        filter.addAction(ACTION_USB_PERMISSION);
+        filter.addAction(ACTION_USB_DETACHED);
+        filter.addAction(ACTION_USB_ATTACHED);
+        registerReceiver(usbReceiver, filter);
+    }
+
+    /*
+     * Request user permission. The response will be received in the BroadcastReceiver
+     */
+    private void requestUserPermission() {
+        PendingIntent mPendingIntent = PendingIntent.getBroadcast(this, 0, new Intent(ACTION_USB_PERMISSION), 0);
+        usbManager.requestPermission(device, mPendingIntent);
+    }
+
+    public class UsbBinder extends Binder {
+        public UsbService getService() {
+            return UsbService.this;
+        }
+    }
+
+    /*
+     * A simple thread to open a serial port.
+     * Although it should be a fast operation. moving usb operations away from UI thread is a good thing.
+     */
+    private class ConnectionThread extends Thread {
+        @Override
+        public void run() {
+            serialPort = UsbSerialDevice.createUsbSerialDevice(device, connection);
+            if (serialPort != null) {
+                if (serialPort.syncOpen()) {
+                    serialPortConnected = true;
+                    serialPort.setBaudRate(BAUD_RATE);
+                    serialPort.setDataBits(UsbSerialInterface.DATA_BITS_8);
+                    serialPort.setStopBits(UsbSerialInterface.STOP_BITS_1);
+                    serialPort.setParity(UsbSerialInterface.PARITY_NONE);
+                    /**
+                     * Current flow control Options:
+                     * UsbSerialInterface.FLOW_CONTROL_OFF
+                     * UsbSerialInterface.FLOW_CONTROL_RTS_CTS only for CP2102 and FT232
+                     * UsbSerialInterface.FLOW_CONTROL_DSR_DTR only for CP2102 and FT232
+                     */
+                    serialPort.setFlowControl(UsbSerialInterface.FLOW_CONTROL_OFF);
+                    serialPort.read(mCallback);
+                    serialPort.getCTS(ctsCallback);
+                    serialPort.getDSR(dsrCallback);
+
+                    new ReadThread().start();
+
+                    //
+                    // Some Arduinos would need some sleep because firmware wait some time to know whether a new sketch is going
+                    // to be uploaded or not
+                    //Thread.sleep(2000); // sleep some. YMMV with different chips.
+
+                    // Everything went as expected. Send an intent to MainActivity
+                    Intent intent = new Intent(ACTION_USB_READY);
+                    context.sendBroadcast(intent);
+                } else {
+                    // Serial port could not be opened, maybe an I/O error or if CDC driver was chosen, it does not really fit
+                    // Send an Intent to Main Activity
+                    if (serialPort instanceof CDCSerialDevice) {
+                        Intent intent = new Intent(ACTION_CDC_DRIVER_NOT_WORKING);
+                        context.sendBroadcast(intent);
+                    } else {
+                        Intent intent = new Intent(ACTION_USB_DEVICE_NOT_WORKING);
+                        context.sendBroadcast(intent);
+                    }
+                }
+            } else {
+                // No driver for given device, even generic CDC driver could not be loaded
+                Intent intent = new Intent(ACTION_USB_NOT_SUPPORTED);
+                context.sendBroadcast(intent);
+            }
+        }
+    }
+
+    private class ReadThread extends Thread {
+        @Override
+        public void run() {
+            while(true){
+                byte[] buffer = new byte[100];
+                int n = serialPort.syncRead(buffer, 0);
+                if(n > 0) {
+                    byte[] received = new byte[n];
+                    System.arraycopy(buffer, 0, received, 0, n);
+                    String receivedStr = new String(received);
+                    mHandler.obtainMessage(SYNC_READ, receivedStr).sendToTarget();
+                }
+            }
+        }
+    }
+}
+

examplesync/src/main/res/layout/activity_main.xml

@@ -0,0 +1,82 @@
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+                xmlns:tools="http://schemas.android.com/tools"
+                android:layout_width="match_parent"
+                android:layout_height="match_parent"
+                android:paddingBottom="16dp"
+                android:paddingLeft="16dp"
+                android:paddingRight="16dp"
+                android:paddingTop="16dp"
+                tools:context="com.felhr.serialportexamplesync.MainActivity">
+
+    <TextView
+        android:id="@+id/textViewTitle"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_alignParentTop="true"
+        android:layout_centerHorizontal="true"
+        android:text="@string/serial_port"
+        android:textAppearance="?android:attr/textAppearanceLarge"/>
+
+    <TextView
+        android:id="@+id/textView1"
+        android:layout_width="match_parent"
+        android:layout_height="150dp"
+        android:layout_centerHorizontal="true"
+        android:layout_marginTop="34dp"
+        android:background="#FFFFFF"
+        android:scrollbars="vertical"
+        android:gravity="bottom" />
+
+    <EditText
+        android:id="@+id/editText1"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_alignLeft="@+id/textView1"
+        android:layout_alignRight="@+id/textView1"
+        android:layout_below="@+id/textView1"
+        android:layout_marginTop="28dp"
+        android:ems="10">
+
+        <requestFocus/>
+    </EditText>
+
+    <Button
+        android:id="@+id/buttonSend"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_alignLeft="@+id/editText1"
+        android:layout_alignRight="@+id/editText1"
+        android:layout_below="@+id/editText1"
+        android:layout_marginTop="42dp"
+        android:text="Send"/>
+
+    <CheckBox
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:text="9600"
+        android:id="@+id/checkBox"
+        android:checked="true"
+        android:layout_alignParentLeft="true"
+        android:layout_alignParentStart="true"
+        android:layout_below="@+id/buttonSend"/>
+
+    <CheckBox
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:text="38400"
+        android:id="@+id/checkBox2"
+        android:layout_alignParentRight="true"
+        android:layout_alignParentEnd="true"
+        android:layout_below="@+id/buttonSend"/>
+
+    <Button
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:text="Set baud rate"
+        android:id="@+id/buttonBaudrate"
+        android:layout_below="@+id/checkBox"
+        android:layout_alignRight="@+id/checkBox2"
+        android:layout_alignEnd="@+id/checkBox2"
+        android:layout_alignParentLeft="true"
+        android:layout_alignParentStart="true"/>
+</RelativeLayout>

examplesync/src/main/res/values/colors.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="colorPrimary">#3F51B5</color>
+    <color name="colorPrimaryDark">#303F9F</color>
+    <color name="colorAccent">#FF4081</color>
+</resources>

examplesync/src/main/res/values/strings.xml

@@ -0,0 +1,6 @@
+<resources>
+    <string name="app_name">ExampleSync</string>
+    <string name="hello_world">Hello world!</string>
+    <string name="action_settings">Settings</string>
+    <string name="serial_port">Synchronous Serial Port</string>
+</resources>

examplesync/src/main/res/values/styles.xml

@@ -0,0 +1,11 @@
+<resources>
+
+    <!-- Base application theme. -->
+    <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
+        <!-- Customize your theme here. -->
+        <item name="colorPrimary">@color/colorPrimary</item>
+        <item name="colorPrimaryDark">@color/colorPrimaryDark</item>
+        <item name="colorAccent">@color/colorAccent</item>
+    </style>
+
+</resources>

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
-#Mon Jul 18 23:57:52 CEST 2016
+#Fri Sep 16 18:22:23 CEST 2016
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-2.10-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.14.1-all.zip

settings.gradle

@@ -1 +1 @@
-include ':usbserial', ':example'
+include ':usbserial', ':example', ':examplesync'

usbserial/src/main/java/com/felhr/usbserial/FTDISerialDevice.java

@@ -631,10 +631,14 @@ public class FTDISerialDevice extends UsbSerialDevice
 
         do
         {
-            int timeLeft = (int) (stopTime - System.currentTimeMillis());
-            if(timeLeft <= 0)
+            int timeLeft = 0;
+            if(timeout > 0)
             {
-                break;
+                timeLeft = (int) (stopTime - System.currentTimeMillis());
+                if (timeLeft <= 0)
+                {
+                    break;
+                }
             }
 
             int numberBytes = connection.bulkTransfer(inEndpoint, tempBuffer, tempBuffer.length, timeLeft);