public class MainActivity extends AppCompatActivity {

private Boolean statusUSB = false;

/*
 * 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 Listo1233", Toast.LENGTH_SHORT).show();
                break;
            case UsbService.ACTION_USB_ATTACHED: // ACTION_USB_ATTACHED
                Toast.makeText( context, "Usb Conectado2!", 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 Desonectado2!", Toast.LENGTH_SHORT).show();
                break;
            case UsbService.ACTION_USB_READY: // USB NOT SUPPORTED
                Toast.makeText(context, "USB Isto", Toast.LENGTH_SHORT).show();
                break;
        }
    }
};
private UsbService usbService;
private TextView display1, display2;
private EditText editText1, editText2;
private Button button1, button2;
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);

    Bundle bundle = getIntent().getExtras();
    statusUSB = bundle.getBoolean("statusUSBX");

    display1 = findViewById(R.id.textView1);
    display2 = findViewById(R.id.textView2);

    mHandler = new MyHandler(this);
}

@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

    Bundle bundle = this.getIntent().getExtras();
    if(bundle != null) {
        //statusUSB = bundle.getBoolean( "statusUSBX" );

        if (statusUSB == true) {
            Toast.makeText( this, "Usb Conectado!", Toast.LENGTH_SHORT ).show();
        }
        if (statusUSB == false) {
            Toast.makeText( this, "Usb Desconectado!", Toast.LENGTH_SHORT ).show();
        }
    }
}

@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.SYNC_READ:
                String buffer = (String) msg.obj;
                if(msg.arg1 == 0){
                    mActivity.get().display1.append(buffer);
                }else if(msg.arg1 == 1){
                    mActivity.get().display2.append(buffer);
                }

                break;
        }
    }
}
}

public class UsbService extends Service implements SerialPortCallback {

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 List<UsbSerialDevice> serialPorts;

private Context context;
private UsbManager usbManager;
private SerialPortBuilder builder;

private Handler writeHandler;
private WriteThread writeThread;

private ReadThreadCOM readThreadCOM1, readThreadCOM2;

private IBinder binder = new UsbBinder();

private Handler mHandler;

private Boolean statusUSB = false;

/*
 * 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_ATTACHED)) {
            boolean ret = builder.openSerialPorts( context, BAUD_RATE,
                    UsbSerialInterface.DATA_BITS_8,
                    UsbSerialInterface.STOP_BITS_1,
                    UsbSerialInterface.PARITY_NONE,
                    UsbSerialInterface.FLOW_CONTROL_OFF );
            if (ret){
                Toast.makeText( context, "Usb Conectado1!", Toast.LENGTH_SHORT ).show();

                statusUSB = true;
                Intent intent2 = new Intent(context, MainActivity.class );
                intent2.putExtra( "statusUSBX", true );
                startActivity(intent2);
            }

        } else if (arg1.getAction().equals(ACTION_USB_DETACHED)) {

            UsbDevice usbDevice = arg1.getParcelableExtra(UsbManager.EXTRA_DEVICE);
            boolean ret = builder.disconnectDevice(usbDevice);
            Toast.makeText(context, "Usb Desonectado1!", Toast.LENGTH_SHORT).show();

            Intent intent = new Intent(ACTION_USB_DISCONNECTED);
            arg0.sendBroadcast(intent);

            statusUSB = false;
            Intent intent2 = new Intent(context, MainActivity.class );
            intent2.putExtra( "statusUSBX", false );
            startActivity(intent2);
        }
    }
};

@Override
public void onSerialPortsDetected(List<UsbSerialDevice> serialPorts) {
    this.serialPorts = serialPorts;

    if(serialPorts.size() == 0)
        return;

    if (writeThread == null) {
        writeThread = new WriteThread();
        writeThread.start();
    }

    int index = 0;

    if (readThreadCOM1 == null && index <= serialPorts.size()-1
            && serialPorts.get(index).isOpen()) {
        readThreadCOM1 = new ReadThreadCOM(index,
                serialPorts.get(index).getInputStream());
        readThreadCOM1.start();
    }

    index++;
    if(readThreadCOM2 == null && index <= serialPorts.size()-1
            && serialPorts.get(index).isOpen()){
        readThreadCOM2 = new ReadThreadCOM(index,
                serialPorts.get(index).getInputStream());
        readThreadCOM2.start();
    }
}

@Override
public void onCreate() {
    this.context = this;
    UsbService.SERVICE_CONNECTED = true;
    setFilter();
    usbManager = (UsbManager) getSystemService(Context.USB_SERVICE);
    builder = SerialPortBuilder.createSerialPortBuilder(this);

    boolean ret = builder.openSerialPorts(context, BAUD_RATE,
            UsbSerialInterface.DATA_BITS_8,
            UsbSerialInterface.STOP_BITS_1,
            UsbSerialInterface.PARITY_NONE,
            UsbSerialInterface.FLOW_CONTROL_OFF);

    if(!ret) {
        Toast.makeText( context, "No Usb serial ports available", Toast.LENGTH_SHORT ).show();
        UsbService.SERVICE_CONNECTED = false;
    }
}

@Nullable
@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();
    if(builder != null)
        builder.unregisterListeners(context);
    UsbService.SERVICE_CONNECTED = false;
}

public void write(byte[] data, int port){
    if(writeThread != null)
        writeHandler.obtainMessage(0, port, 0, data).sendToTarget();
}

public void setHandler(Handler mHandler) {
    this.mHandler = mHandler;
}


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);
}

public class UsbBinder extends Binder {
    public UsbService getService() {
        return UsbService.this;
    }
}

private class ReadThreadCOM extends Thread {
    private int port;
    private AtomicBoolean keep = new AtomicBoolean(true);
    private SerialInputStream inputStream;

    public ReadThreadCOM(int port, SerialInputStream serialInputStream){
        this.port = port;
        this.inputStream = serialInputStream;
    }

    @Override
    public void run() {
        while(keep.get()){
            if(inputStream == null)
                return;
            int value = inputStream.read();
            if(value != -1) {
                String str = toASCII(value);
                mHandler.obtainMessage(SYNC_READ, port, 0, str).sendToTarget();
            }
        }
    }

    public void setKeep(boolean keep){
        this.keep.set(keep);
    }
}

private static String toASCII(int value) {
    int length = 4;
    StringBuilder builder = new StringBuilder(length);
    for (int i = length - 1; i >= 0; i--) {
        builder.append((char) ((value >> (8 * i)) & 0xFF));
    }
    return builder.toString();
}

private class WriteThread extends Thread{

    @Override
    @SuppressLint("HandlerLeak")
    public void run() {
        Looper.prepare();
        writeHandler = new Handler(){
            @Override
            public void handleMessage(Message msg) {
                int port = msg.arg1;
                byte[] data = (byte[]) msg.obj;
                if(port <= serialPorts.size()-1) {
                    UsbSerialDevice serialDevice = serialPorts.get(port);
                    serialDevice.getOutputStream().write(data);
                }
            }
        };
        Looper.loop();
    }
}