Make 'write()' return number of bytes written

Some thoughts about java-native#129

What this commit does:

- Make native impls return numberOfBytesWritten.
- Throw SerialPortException in case write fails in some way.
- Expose new 'write()' method to java which returns
  numberOfBytesWritten and uses exceptions for error handling.
- Keep old 'writeBytes()' method and translate to the old behavior.

What this commit does NOT:

THIS CODE IS NOT TESTED! It even was not launched at all. Nevertheless
it did compile fine for x86_64-linux-gnu (debian) and mingw
(cross-compile). So we need to do:

- Testing!
- Review if the change in the API (adding a 'write()' method) is the
  thing we should do or if we should do it differently somehow.

(wip @ 36ee5d8)

src/main/cpp/_nix_based/jssc.cpp

@@ -24,6 +24,7 @@
  */
 #include <limits.h>
 #include <stdio.h>
+#include <string.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <sys/ioctl.h>
@@ -525,13 +526,16 @@ JNIEXPORT jboolean JNICALL Java_jssc_SerialNativeInterface_setDTR
 /*
  * Writing data to the port
  */
-JNIEXPORT jboolean JNICALL Java_jssc_SerialNativeInterface_writeBytes
+JNIEXPORT jint JNICALL Java_jssc_SerialNativeInterface_write
   (JNIEnv *env, jobject, jlong portHandle, jbyteArray buffer){
     jbyte* jBuffer = env->GetByteArrayElements(buffer, JNI_FALSE);
     jint bufferSize = env->GetArrayLength(buffer);
     jint result = write(portHandle, jBuffer, (size_t)bufferSize);
     env->ReleaseByteArrayElements(buffer, jBuffer, 0);
-    return result == bufferSize ? JNI_TRUE : JNI_FALSE;
+    if( result < 0 ){ /* aka error */
+        return env->ThrowNew(env->FindClass("jssc/SerialPortException"), strerror(errno));
+    }
+    return result;
 }
 
 /**

src/main/cpp/windows/jssc.cpp

@@ -231,28 +231,31 @@ JNIEXPORT jboolean JNICALL Java_jssc_SerialNativeInterface_setDTR
  * portHandle - port handle
  * buffer - byte array for sending
  */
-JNIEXPORT jboolean JNICALL Java_jssc_SerialNativeInterface_writeBytes
+JNIEXPORT jint JNICALL Java_jssc_SerialNativeInterface_write
   (JNIEnv *env, jobject, jlong portHandle, jbyteArray buffer){
     HANDLE hComm = (HANDLE)portHandle;
     DWORD lpNumberOfBytesTransferred;
     DWORD lpNumberOfBytesWritten;
     OVERLAPPED *overlapped = new OVERLAPPED();
-    jboolean returnValue = JNI_FALSE;
+    jint returnValue = -1;
     jbyte* jBuffer = env->GetByteArrayElements(buffer, JNI_FALSE);
     overlapped->hEvent = CreateEventA(NULL, true, false, NULL);
     if(WriteFile(hComm, jBuffer, (DWORD)env->GetArrayLength(buffer), &lpNumberOfBytesWritten, overlapped)){
-        returnValue = JNI_TRUE;
+        returnValue = lpNumberOfBytesWritten;
     }
     else if(GetLastError() == ERROR_IO_PENDING){
         if(WaitForSingleObject(overlapped->hEvent, INFINITE) == WAIT_OBJECT_0){
             if(GetOverlappedResult(hComm, overlapped, &lpNumberOfBytesTransferred, false)){
-                returnValue = JNI_TRUE;
+                returnValue = lpNumberOfBytesTransferred;
             }
         }
     }
     env->ReleaseByteArrayElements(buffer, jBuffer, 0);
     CloseHandle(overlapped->hEvent);
     delete overlapped;
+    if( returnValue < 0 ){
+        return env->ThrowNew(env->FindClass("jssc/SerialPortException"), "WriteFile() failed");
+    }
     return returnValue;
 }
 

src/main/java/jssc/SerialNativeInterface.java

@@ -277,7 +277,7 @@ public static String getLibraryVersion() {
      * 
      * @return If the operation is successfully completed, the method returns true, otherwise false
      */
-    public native boolean writeBytes(long handle, byte[] buffer);
+    public native int write(long handle, byte[] buffer) throws SerialPortException;
 
     /**
      * Get bytes count in buffers of port

src/main/java/jssc/SerialPort.java

@@ -408,7 +408,28 @@ public boolean setDTR(boolean enabled) throws SerialPortException {
      */
     public boolean writeBytes(byte[] buffer) throws SerialPortException {
         checkPortOpened("writeBytes()");
-        return serialInterface.writeBytes(portHandle, buffer);
+        // Delegate to new method and translate result to what original method
+        // did return.
+        try{
+            int result = write(buffer);
+            return result == buffer.length;
+        }catch (SerialPortException ex) {
+            return false;
+        }
+    }
+
+    /**
+     * Write byte array to port
+     *
+     * @param buffer <code>byte[]</code> array to write
+     *
+     * @return If the operation is successfully completed, the method returns true, otherwise false
+     * 
+     * @throws SerialPortException if exception occurred
+     */
+    public int write(byte[] buffer) throws SerialPortException {
+        checkPortOpened("writeBytes()");
+        return serialInterface.write(portHandle, buffer);
     }
 
     /**
@@ -1392,4 +1413,5 @@ public void run() {
             }
         }
     }
+
 }