Android通过JNI操作串口《二》

3.
JNI实现类
#include
"JNIHelp.h"
#include
"android_runtime/AndroidRuntime.h"
#include
<utils/misc.h>
#include
<utils/Log.h>
#include
<utils/threads.h>
#include
<pthread.h>
#include
<stdio.h>
#include
<sys/types.h>
#include
<sys/stat.h>
#include
<fcntl.h>
#include
<string.h>
#include
<utils/Log.h>
#include
<sys/ioctl.h>
#include
<termios.h>

#include
"com_notioni_uart_manager_TtyNativeControl.h"

using
namespace android;

struct
fields_t{

jfieldID tty;

jmethodID post_event;
};
static
fields_t fields;
JavaVM* g_JavaVM;

#define
TTY_DEVICE "/dev/ttyS2"

#define
LOG_TAG "TtyNativeControl"
#define
RECEIVE_DATA_INDEX (1)

#define
POST_EVENT()
static
int mTtyfd = -1;
static
int mOpen = 0;

/**
* class Listener
*/
class
JNIMyObserver{
public:

JNIMyObserver(JNIEnv* env,jobject thiz,jobject weak_thiz);

~JNIMyObserver();

void
OnEvent(const
char* buffer,int
length,int what);
private:

JNIMyObserver();

jclass mClass;

jobject mObject;

Mutex mLock;
};
JNIMyObserver::JNIMyObserver(JNIEnv*
env,jobject thiz,jobject weak_thiz){

jclass clazz = env->GetObjectClass(thiz);

if(clazz == NULL){

//
jniThrowException(env,"java/lang/Exception",NULL);

LOGE("clazz is null");

return;

}

mClass = (jclass)env->NewGlobalRef(clazz);

mObject = env->NewGlobalRef(weak_thiz);

LOGW("mClass=%d",mClass);

LOGW("mObject=%d",mObject);
}
JNIMyObserver::~JNIMyObserver(){

JNIEnv *env = AndroidRuntime::getJNIEnv();

env->DeleteGlobalRef(mObject);

env->DeleteGlobalRef(mClass);
}
void
JNIMyObserver::OnEvent(const
char* buffer,int
length,int what){

LOGW("OnEvent");

Mutex::Autolock _l(mLock);

if(NULL == g_JavaVM){

LOGE("JNIObserver::Event g_JavaVM is NULL");

return;

}

bool isAttacked =
false;

/*

* 创建env指针

*/

JNIEnv* env;

bool status = (g_JavaVM->GetEnv((void**)
&env,JNI_VERSION_1_4) != JNI_OK);

if(status){

g_JavaVM->AttachCurrentThread(&env,NULL);

}

/*

* 创建J***A byte[]数组

*/

jbyteArray obj = NULL;

if(buffer !=NULL && buffer != 0){

const jbyte* data =
reinterpret_cast<const
jbyte*>(buffer);

obj = env->NewByteArray(length);

env->SetByteArrayRegion(obj,0,length,data);

}

env->CallStaticVoidMethod(mClass,fields.post_event,mObject,what,0,0,obj);

if(obj){

env->DeleteLocalRef(obj);

}

if(isAttacked){

g_JavaVM->DetachCurrentThread();//分离线程

}

}
/**
* class Listener
end -----------------
*/





JNIMyObserver* listener;
/*
* setup
*/
static
void JNICALL com_notioni_uart_manager_TtyNativeControl_native_setup(JNIEnv
*env,jobject clazz,jobject weak_this){

LOGW("com_notioni_uart_manager_TtyNativeControl_native_setup");

env->GetJavaVM(&g_JavaVM);

if(listener != NULL){

delete listener;

}

listener = new JNIMyObserver(env,clazz,weak_this);
}
/*
* _openTty
*/
static
int JNICALL com_notioni_uart_manager_TtyNativeControl__openTty(JNIEnv
*env,jobject clazz){

LOGW("com_notioni_uart_manager_TtyNativeControl__openTty");

mTtyfd = open(TTY_DEVICE,O_RDWR|O_NONBLOCK);//读写方式

if(mTtyfd < 0){

LOGE("mTtyfd open failure");

return -1;

}

if(fcntl(mTtyfd,F_SETFL,0)<0){//恢复串口为堵塞状态

LOGE("mTtyfd fcntl failure");

}
//
if(isatty(STDIN_FILENO)==0){//测试是否为中断设备，非0即使终端设备
//
LOGE("standard inputs is not a terminal device");
//
}else{
//
LOGE("isatty success");
//
}

mOpen = 1;

LOGW("open device success");

return 1;
}
/*
* _closeTty
*/
static
int JNICALL com_notioni_uart_manager_TtyNativeControl__closeTty(JNIEnv
*env,jobject clazz){

LOGW("com_notioni_uart_manager_TtyNativeControl__closeTty");

if(mTtyfd < 0){

LOGE("mTtyfd open failure ,non't close");

return -1;

}

mOpen = 0;

sleep(2);//等待线程退出

int c = close(mTtyfd);

if(c < 0){

LOGE("mTtyfd close failure");

return -1;

}

LOGW("close device success");

return 1;
}

/*
* _sendMsgToTty
*/
static
int JNICALL com_notioni_uart_manager_TtyNativeControl__sendMsgToTty(JNIEnv
*env,jobject clazz,jbyteArray data){//byte[]

LOGW("com_notioni_uart_manager_TtyNativeControl__sendMsgToTty");

//jbyte * arrayBody = env->GetByteArrayElements(data,0); jsize theArrayLengthJ = env->GetArrayLength(data); BYTE * starter = (BYTE *)arrayBody;

if(mTtyfd < 0){

LOGE("mTtyfd open failure ,non't write");

return -1;

}


jbyte* arrayData = (jbyte*)env->GetByteArrayElements(data,0);

jsize arrayLength = env->GetArrayLength(data);

char* byteData = (char*)arrayData;

int len = (int)arrayLength;

LOGW("write data len:%d",len);

int re = write(mTtyfd,byteData,len);

if(re == -1){

LOGE("write device error");

}

return re;
}

/*
*
线程Run
*/
void*
threadreadTtyData(void* arg){

LOGW("run read data");

if(!(arg)){

return NULL;

}

char* buf =
new
char[200];

int result = 0,ret;

fd_set readfd;

struct
timeval timeout;

while(mOpen){

timeout.tv_sec = 2;//设定超时秒数

timeout.tv_usec = 0;//设定超时毫秒数


FD_ZERO(&readfd);//清空集合

FD_SET(mTtyfd,&readfd);///*
把要检测的句柄mTtyfd加入到集合里
*/

ret = select(mTtyfd+1,&readfd,NULL,NULL,&timeout);/*
检测我们上面设置到集合readfd里的句柄是否有可读信息
*/


switch(ret){

case -1:/*
这说明select函数出错
*/

result = -1;

LOGE("mTtyfd read failure");

break;

case 0:/*
说明在我们设定的时间值5秒加0毫秒的时间内，mTty的状态没有发生变化
*/

break;

default:/*
说明等待时间还未到5秒加0毫秒，mTty的状态发生了变化
*/

if(FD_ISSET(mTtyfd,&readfd)){/*
先判断一下mTty这外被监视的句柄是否真的变成可读的了
*/

int len = read(mTtyfd,buf,sizeof(buf));

/**发送数据**/

if(!(arg))break;

JNIMyObserver *l =
static_cast<JNIMyObserver
*>(arg);

l->OnEvent(buf,len,RECEIVE_DATA_INDEX);

memset(buf,0,sizeof(buf));

}

break;

}

if(result == -1){

break;

}

}

if(buf != NULL){

delete buf;

buf = NULL;

}

LOGE("stop run!");

return NULL;
}
/*
* _receiveMsgFromTty
*/
static
void JNICALL com_notioni_uart_manager_TtyNativeControl__receiveMsgFromTty(JNIEnv
*env,jobject clazz){

LOGW("com_notioni_uart_manager_TtyNativeControl__receiveMsgFromTty");

if(mTtyfd < 0){

LOGE("mTtyfd open failure ,non't read");

return ;

}

pthread_t id;

int ret;

ret = pthread_create(&id,NULL,threadreadTtyData,listener);

if(ret != 0){

LOGE("create receiver thread failure ");

}else{

LOGW("create read data thred success");

}


}


/**
*
设置串口数据，校验位,速率，停止位
* @param nBits
类型
int数据位
取值
位7或8
* @param nEvent
类型
char 校验类型
取值N ,E, O,,S
* @param mSpeed
类型
int 速率
取值 2400,4800,9600,115200
* @param mStop
类型
int 停止位
取值1
或者 2
*/
int
set_opt(int nBits,char
nEvent,int nSpeed,int
nStop){

LOGW("set_opt:nBits=%d,nEvent=%c,nSpeed=%d,nStop=%d",nBits,nEvent,nSpeed,nStop);

struct
termios newtio,oldtio;

if(tcgetattr(mTtyfd,&oldtio) != 0){

LOGE("setup serial failure");

return -1;

}

bzero(&newtio,sizeof(newtio));
//c_cflag标志可以定义CLOCAL和CREAD，这将确保该程序不被其他端口控制和信号干扰，同时串口驱动将读取进入的数据。CLOCAL和CREAD通常总是被是能的

newtio.c_cflag |=CLOCAL|CREAD;

//newtio.c_cflag &=~CSIZE;


switch(nBits){//设置数据位数

case 7:

newtio.c_cflag &=~CSIZE;

newtio.c_cflag |=CS7;

break;

case 8:

newtio.c_cflag &=~CSIZE;

newtio.c_cflag |=CS8;

break;

default:

LOGW("nBits:%d,invalid
param",nBits);

break;

}


switch(nEvent){//设置校验位

case
'O':

newtio.c_cflag |=PARENB;//enable parity checking

newtio.c_cflag |=PARODD;//奇校验位

newtio.c_iflag |=(INPCK|ISTRIP);

//options.c_iflag |= INPCK;//Disable parity checking

break;

case
'E':

newtio.c_cflag|=PARENB;//

newtio.c_cflag&=~PARODD;//偶校验位

newtio.c_iflag|=(INPCK|ISTRIP);

//options.c_iflag |= INPCK;//Disable parity checking

break;

case
'N':

newtio.c_cflag &=~PARENB;//清除校验位

//options.c_iflag &=~INPCK;//Enable parity checking

break;

//case 'S':

//
options.c_cflag &= ~PARENB;//清除校验位

//
options.c_cflag &=~CSTOPB;

//
options.c_iflag |=INPCK;//Disable parity checking

//
break;

default:

LOGW("nEvent:%c,invalid
param",nEvent);

break;

}

switch(nSpeed){//设置速率

case 2400:

LOGW("B2400:%d",B2400);

cfsetispeed(&newtio,B2400);

cfsetospeed(&newtio,B2400);

break;

case 4800:

LOGW("B4800:%d",B4800);

cfsetispeed(&newtio,B4800);

cfsetospeed(&newtio,B4800);

break;

case 9600:

LOGW("B9600:%d",B9600);

cfsetispeed(&newtio,B9600);

cfsetospeed(&newtio,B9600);

break;

case 115200:

LOGW("B115200:%d",B115200);

cfsetispeed(&newtio,B115200);

cfsetospeed(&newtio,B115200);

break;

default:

cfsetispeed(&newtio,B9600);

cfsetospeed(&newtio,B9600);



LOGW("nSpeed:%d,invalid
param",nSpeed);

break;

}


switch(nStop){//设置停止位

case 1:

newtio.c_cflag &= ~CSTOPB;

break;

case 2:

newtio.c_cflag |= CSTOPB;

break;

default:

LOGW("nStop:%d,invalid
param",nStop);

break;

}


newtio.c_cc[VTIME] = 0;//设置等待时间

newtio.c_cc[VMIN] = 0;//设置最小接收字符

tcflush(mTtyfd,TCIFLUSH);

if(tcsetattr(mTtyfd,TCSANOW,&newtio) != 0){

LOGE("options set error");

return -1;

}

return 1;
}

/*
* _configTty
*/
static
int JNICALL com_notioni_uart_manager_TtyNativeControl__configTty(JNIEnv
*env,jobject clazz,int nBits,jchar nEvent,int
nSpeed,int nStop){

LOGW("com_notioni_uart_manager_TtyNativeControl__configTty");

return set_opt(nBits,nEvent,nSpeed,nStop);
}

int
set_mode(int nMode,int
showLog){

LOGW("set_mode:nMode%d,nshowLog=%d",nMode,showLog);

struct
termios options;

if(tcgetattr(mTtyfd,&options) != 0){

LOGE("setup serial failure");

return -1;

}

int
result = 1;

if(nMode != 0){

if(nMode ==1){

options.c_lflag &=~(ICANON | ECHO | ECHOE | ISIG);//input

options.c_oflag &=~OPOST;//out put

}else
if(nMode == 2){

options.c_lflag |=(ICANON | ECHO | ECHOE | ISIG);//input

options.c_oflag |=OPOST;//out put

}

if(tcsetattr(mTtyfd,TCSANOW,&options) != 0){

LOGE("tcsetattr device fail");

result = -1;

}

}

if(showLog == 1){

LOGI("options c_cflag.CS7:%d,CS8:%d",options.c_cflag & CS7,options.c_cflag
& CS8);

LOGI("options c_cflag.PARENB:%d,PARODD:%d",options.c_cflag & PARENB,options.c_cflag
& PARODD);

LOGI("options c_iflag.INPCK%d,ISTRIP:%d",options.c_iflag & INPCK,options.c_iflag
& ISTRIP);

LOGI("option c_ispeed:%d,c_ospeed:%d",cfgetispeed(&options) ,cfgetospeed(&options));

LOGI("options c_cflag.CSTOPB:%d,",options.c_cflag & CSTOPB);

LOGI("options c_cc.VTIME:%d,VMIN:%d",options.c_cc[VTIME],options.c_cc[VMIN]);

LOGI("options c_cflag.CLOCAL:%d,CREAD:%d",options.c_cflag & CLOCAL,options.c_cflag&CREAD);

LOGI("options c_lflag.ICANON:%d,ECHO:%d,ECHOE:%d,ISIG:%d",options.c_lflag
& ICANON,options.c_lflag&ECHO,options.c_lflag&ECHOE,options.c_lflag&ISIG);

LOGI("options c_oflag.OPOST:%d,",options.c_oflag &OPOST);

}

return
result;
}
static
int JNICALL com_notioni_uart_manager_TtyNativeControl__setMode(JNIEnv
*env,jobject clazz,int nMode,int
showLog){

LOGW("com_notioni_uart_manager_TtyNativeControl__setMode");

return set_mode(nMode,showLog);
}


static
JNINativeMethod method_table[] = {

{"native_setup","(Ljava/lang/Object;)V",(void
*)com_notioni_uart_manager_TtyNativeControl_native_setup},

{"_openTty","()I",(void
*)com_notioni_uart_manager_TtyNativeControl__openTty},

{"_closeTty","()I",(void
*)com_notioni_uart_manager_TtyNativeControl__closeTty},


{"_sendMsgToTty","([B)I",(void
*)com_notioni_uart_manager_TtyNativeControl__sendMsgToTty},

{"_receiveMsgFromTty","()V",(void
*)com_notioni_uart_manager_TtyNativeControl__receiveMsgFromTty},

{"_configTty","(ICII)I",(void
*)com_notioni_uart_manager_TtyNativeControl__configTty},

{"_setMode","(II)I",(void
*)com_notioni_uart_manager_TtyNativeControl__setMode},
};

static
const
char* classPathName="com/notioni/uart/manager/TtyNativeControl";
static
int
register_com_notioni_uart_manager_TtyNativeControl(JNIEnv *env){

LOGW("register_com_notioni_uart_manager_TtyNativeControl");

jclass clazz;

clazz = env->FindClass(classPathName);

if(clazz == NULL){

return -1;

}

fields.post_event = env->GetStaticMethodID(clazz,"postEventFromNative",

"(Ljava/lang/Object;IIILjava/lang/Object;)V");

if(fields.post_event
== NULL){

LOGE("Can't find
com/notioni/uart/manager.postEventFromNative");

return -1;

}

return AndroidRuntime::registerNativeMethods(env,classPathName,method_table,NELEM(method_table));
}

jint
JNI_OnLoad(JavaVM* vm,void* reserved){

LOGW("JNI_OnLoad");

JNIEnv* env = NULL;

jint result = -1;

if(vm->GetEnv((void**)&env,JNI_VERSION_1_4)
!= JNI_OK){

goto bail;

}

LOGW("register
mothod");

assert(env != NULL);

if(register_com_notioni_uart_manager_TtyNativeControl(env)
< 0){

goto bail;

}

return JNI_VERSION_1_4;
bail:

return result;
}