/*
 * Copyright 2009-2011 Cedric Priscal
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <termios.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>
#include <jni.h>

#include "SerialPort.h"

#include "android/log.h"
static const char *TAG="serial_port";
#define LOGI(fmt, args...) __android_log_print(ANDROID_LOG_INFO,  TAG, fmt, ##args)
#define LOGD(fmt, args...) __android_log_print(ANDROID_LOG_DEBUG, TAG, fmt, ##args)
#define LOGE(fmt, args...) __android_log_print(ANDROID_LOG_ERROR, TAG, fmt, ##args)

static speed_t getBaudrate(jint baudrate)
{
        switch(baudrate) {
        case 0: return B0;
        case 50: return B50;
        case 75: return B75;
        case 110: return B110;
        case 134: return B134;
        case 150: return B150;
        case 200: return B200;
        case 300: return B300;
        case 600: return B600;
        case 1200: return B1200;
        case 1800: return B1800;
        case 2400: return B2400;
        case 4800: return B4800;
        case 9600: return B9600;
        case 19200: return B19200;
        case 38400: return B38400;
        case 57600: return B57600;
        case 115200: return B115200;
        case 230400: return B230400;
        case 460800: return B460800;
        case 500000: return B500000;
        case 576000: return B576000;
        case 921600: return B921600;
        case 1000000: return B1000000;
        case 1152000: return B1152000;
        case 1500000: return B1500000;
        case 2000000: return B2000000;
        case 2500000: return B2500000;
        case 3000000: return B3000000;
        case 3500000: return B3500000;
        case 4000000: return B4000000;
        default: return -1;
        }
}

static int getParity(jint parity)
{
	switch (parity) {
	case 1: return PARENB | PARODD;
	case 2: return PARENB;
	}
	return 0;
}

static int getSize(jint size)
{
	switch (size){
	case 6: return CS6;
	case 7: return CS7;
	case 8: return CS8;
	}
	return 0;
}

static int getStopBit(jint stopb)
{
	switch (stopb){
	case 2: return CSTOPB;
	}
	return 0;
}

/*
 * Class:     android_serialport_SerialPort
 * Method:    open
 * Signature: (Ljava/lang/String;II)Ljava/io/FileDescriptor;
 */
JNIEXPORT jobject JNICALL Java_ru_wadman_serialport_SerialPort_open
  (JNIEnv *env, jclass thiz, jstring path, jint flags)
{
        jobject mFileDescriptor;
        int fd;

        /* Opening device */
        {
                jboolean iscopy;
                const char *path_utf = (*env)->GetStringUTFChars(env, path, &iscopy);
                LOGD("Opening serial port %s with flags 0x%x", path_utf, O_RDWR | flags);
                fd = open(path_utf, O_RDWR | flags);
                LOGD("open() fd = %d", fd);
                (*env)->ReleaseStringUTFChars(env, path, path_utf);
                if (fd == -1)
                {
                        /* Throw an exception */
                        LOGE("Cannot open port");
                        /* TODO: throw an exception */
                        return NULL;
                }
        }

        /* Create a corresponding file descriptor */
        {
                jclass cFileDescriptor = (*env)->FindClass(env, "java/io/FileDescriptor");
                jmethodID iFileDescriptor = (*env)->GetMethodID(env, cFileDescriptor, "<init>", "()V");
                jfieldID descriptorID = (*env)->GetFieldID(env, cFileDescriptor, "descriptor", "I");
                mFileDescriptor = (*env)->NewObject(env, cFileDescriptor, iFileDescriptor);
                (*env)->SetIntField(env, mFileDescriptor, descriptorID, (jint)fd);
        }

        return mFileDescriptor;
}

JNIEXPORT void JNICALL Java_ru_wadman_serialport_SerialPort_config
  (JNIEnv *env, jclass thiz, jint baudrate, jint size, jint parity, jint stops)
{
    int fd;
    speed_t speed;
    /* Check arguments */
	{
		speed = getBaudrate(baudrate);
		if (speed == -1) {
			/* TODO: throw an exception */
			LOGE("Invalid baudrate");
			return;
		}
	}

    jclass SerialPortClass = (*env)->GetObjectClass(env, thiz);
    jclass FileDescriptorClass = (*env)->FindClass(env, "java/io/FileDescriptor");

    jfieldID mFdID = (*env)->GetFieldID(env, SerialPortClass, "mFd", "Ljava/io/FileDescriptor;");
    jfieldID descriptorID = (*env)->GetFieldID(env, FileDescriptorClass, "descriptor", "I");

    jobject mFd = (*env)->GetObjectField(env, thiz, mFdID);
    jint descriptor = (*env)->GetIntField(env, mFd, descriptorID);

    LOGD("config() fd = %d", descriptor);
    /* Configure device */
        {
                struct termios cfg;
                if (tcgetattr(descriptor, &cfg) != 0)
                {
                	LOGE("tcgetattr() failed (fd = %d, err = %d)", descriptor, errno);
                        //close(descriptor);
                        /* TODO: throw an exception */
                        return;
                }

                cfmakeraw(&cfg);
                cfsetispeed(&cfg, speed);
                cfsetospeed(&cfg, speed);

                cfg.c_cflag &= ~PARENB;
                cfg.c_cflag &= ~PARODD;
                cfg.c_cflag &= ~CSIZE;
                cfg.c_cflag &= ~CSTOPB;
                cfg.c_cflag |= (CLOCAL | CREAD) | getSize(size) | getParity(parity) | getStopBit(stops);

                if (tcsetattr(descriptor, TCSANOW, &cfg) != 0)
                {
                        LOGE("tcsetattr() failed (fd = %d, err = %d)", descriptor, errno);
                        //close(descriptor);
                        /* TODO: throw an exception */
                        return;
                }
        }

}

/*
 * Class:     cedric_serial_SerialPort
 * Method:    close
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_ru_wadman_serialport_SerialPort_close
  (JNIEnv *env, jobject thiz)
{
        jclass SerialPortClass = (*env)->GetObjectClass(env, thiz);
        jclass FileDescriptorClass = (*env)->FindClass(env, "java/io/FileDescriptor");

        jfieldID mFdID = (*env)->GetFieldID(env, SerialPortClass, "mFd", "Ljava/io/FileDescriptor;");
        jfieldID descriptorID = (*env)->GetFieldID(env, FileDescriptorClass, "descriptor", "I");

        jobject mFd = (*env)->GetObjectField(env, thiz, mFdID);
        jint descriptor = (*env)->GetIntField(env, mFd, descriptorID);

        LOGD("close() fd = %d", descriptor);
        tcflush(descriptor, TCIOFLUSH);
        close(descriptor);
}

/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class android_serialport_api_SerialPort */

#ifndef _Included_android_serialport_api_SerialPort
#define _Included_android_serialport_api_SerialPort
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     android_serialport_api_SerialPort
 * Method:    open
 * Signature: (Ljava/lang/String;II)Ljava/io/FileDescriptor;
 */
JNIEXPORT jobject JNICALL Java_ru_wadman_serialport_SerialPort_open
  (JNIEnv *, jclass, jstring, jint);

JNIEXPORT void JNICALL Java_ru_wadman_serialport_SerialPort_config
  (JNIEnv *env, jclass, jint, jint, jint, jint);

/*
 * Class:     android_serialport_api_SerialPort
 * Method:    close
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_ru_wadman_serialport_SerialPort_close
  (JNIEnv *, jobject);

#ifdef __cplusplus
}
#endif
#endif

/*
 * Copyright 2009 Cedric Priscal
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License. 
 */

package ru.wadman.serialport;

import java.io.File;
import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

import android.util.Log;

public class SerialPort {

		public final static int SERIALPORT_NOPARITY		= 0;
		public final static int SERIALPORT_ODDPARITY	= 1;
		public final static int SERIALPORT_EVENPARITY	= 2;
		public final static int SERIALPORT_SIZE5		= 5;
		public final static int SERIALPORT_SIZE6		= 6;
		public final static int SERIALPORT_SIZE7		= 7;
		public final static int SERIALPORT_SIZE8		= 8;
		public final static int SERIALPORT_1STOPBIT		= 1;
		public final static int SERIALPORT_2STOPBIT		= 2;

		private static final String TAG = "SerialPort";
        
        /* 
         * Do not remove or rename the field mFd: it is used by native method close();
         */
        private FileDescriptor mFd;
        private FileInputStream mFileInputStream;
        private FileOutputStream mFileOutputStream;

        public SerialPort(File device, int flags) throws SecurityException, IOException {

                /* Check access permission */
                if (!device.canRead() || !device.canWrite()) {
                        try {
                                /* Missing read/write permission, trying to chmod the file */
                                Process su;
                                su = Runtime.getRuntime().exec("su");
                                String cmd = "chmod 666 " + device.getAbsolutePath() + "\n"
                                                + "exit\n";
                                su.getOutputStream().write(cmd.getBytes());
                                if ((su.waitFor() != 0) || !device.canRead()
                                                || !device.canWrite()) {
                                        throw new SecurityException();
                                }
                        } catch (Exception e) {
                                e.printStackTrace();
                                throw new SecurityException();
                        }
                }

                mFd = open(device.getAbsolutePath(), flags);
                if (mFd == null) {
                        Log.e(TAG, "native open returns null");
                        throw new IOException();
                }
                mFileInputStream = new FileInputStream(mFd);
                mFileOutputStream = new FileOutputStream(mFd);
        }

        // Getters and setters
        public InputStream getInputStream() {
                return mFileInputStream;
        }

        public OutputStream getOutputStream() {
                return mFileOutputStream;
        }

        // JNI
        private native static FileDescriptor open(String path, int flags);
        public native void config(int baudrate, int size, int parity, int stopb);
        public native void close();
        static {
                System.loadLibrary("serial_port");
        }
}

  new Thread(new Runnable() {
	 	    	      public void run() {
	 	    	    	 try
	 		 	    	   {							//случайный набор байт
	 	    	    		 Log.d(TAG, "start read");
	 		 	    		   while (1>0)
	 		 	    		   {
	 		 	    		   
		 		 	    		   byte dataToRead[] = {0,0,0};
		 		 	    		   
		 		 	    		   int k = mySerialPort.getInputStream().read(dataToRead); 
		 		 	    		   Log.d(TAG, "readed bytes - "+Integer.toString(k));	 		 	    		   
		 		 	    		   if (k>0) {
		 		 	    			   itemAdapter.clear();	
		 			 	    		   for (int i = 0; i < dataToRead.length; i++) {
		 			 	    		   itemArrey.add(0,Byte.toString(dataToRead[i]));}
		 		 	    		   }
		 		 	    		   
	 		 	    		   }
	 		 	    		  
	 		 	    		    
	 		 	    	   }
	 		 	    	   catch(IOException ioe) 
	 		 	    	   {
	 		 	    		  ioe.printStackTrace();  
	 		 	    	   }	
	 	    	      }
	 	    	    }).start();  

package ru.wadman.serialporttest.app;

/**
 * Created by wadman on 29.05.2014.
 */

import android.app.Activity;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.content.DialogInterface.OnClickListener;
import android.os.Bundle;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.security.InvalidParameterException;

import ru.wadman.serialport.SerialPort;

public abstract class SerialPortActivity extends Activity {

    protected Application mApplication;
    protected SerialPort mSerialPort;
    protected OutputStream mOutputStream;
    private InputStream mInputStream;
    private ReadThread mReadThread;

    private class ReadThread extends Thread {

        @Override
        public void run() {
            super.run();
            while(!isInterrupted()) {
                int size;
                try {
                    byte[] buffer = new byte[64];
                    if (mInputStream == null) return;
                    size = mInputStream.read(buffer);
                    if (size > 0) {
                        onDataReceived(buffer, size);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                    return;
                }
            }
        }
    }

    private void DisplayError(int resourceId) {
        AlertDialog.Builder b = new AlertDialog.Builder(this);
        b.setTitle("Error");
        b.setMessage(resourceId);
        b.setPositiveButton("OK", new OnClickListener() {
            public void onClick(DialogInterface dialog, int which) {
                SerialPortActivity.this.finish();
            }
        });
        b.show();
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mApplication = (Application) getApplication();
        try {
            mSerialPort = mApplication.getSerialPort();
            mOutputStream = mSerialPort.getOutputStream();
            mInputStream = mSerialPort.getInputStream();

                        /* Create a receiving thread */
            mReadThread = new ReadThread();
            mReadThread.start();
        } catch (SecurityException e) {
            DisplayError(R.string.error_security);
        } catch (IOException e) {
            DisplayError(R.string.error_unknown);
        } catch (InvalidParameterException e) {
            DisplayError(R.string.error_configuration);
        }
    }

    protected abstract void onDataReceived(final byte[] buffer, final int size);

    @Override
    protected void onDestroy() {
        if (mReadThread != null)
            mReadThread.interrupt();
        mApplication.closeSerialPort();
        mSerialPort = null;
        super.onDestroy();
    }
}