第一章：android串口开发so库生成_android 串口库-优快云博客

本文链接：https://blog.youkuaiyun.com/2401_86964104/article/details/142148776

public SerialPort(File device, int baudrate, 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(“/system/bin/su”);

String cmd = "chmod 777 " + 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(), baudrate, flags);

if (mFd == null) {

Log.e(TAG, “native open returns null”);

throw new IOException();

}

mFileInputStream = new FileInputStream(mFd);

mFileOutputStream = new FileOutputStream(mFd);

}

public SerialPort(File device, int baudRate, int parity, int dataBits,

int stopBit, 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(“/system/bin/su”);

String cmd = "chmod 777 " + 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(), baudRate, parity, dataBits, stopBit, 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(调用java本地接口，实现串口的打开和关闭)

/**

串口有五个重要的参数：串口设备名，波特率，检验位，数据位，停止位
其中检验位一般默认位NONE,数据位一般默认为8，停止位默认为1

/**

@param path 串口设备的绝对路径
@param baudrate 波特率
@param flags 校验位

private native static FileDescriptor open(String path, int baudrate, int flags);

/**

打开串口
@param path 串口设备文件
@param baudRate 波特率
@param parity 奇偶校验，0 None（默认）； 1 Odd； 2 Even
@param dataBits 数据位，5 ~ 8 （默认8）
@param stopBit 停止位，1 或 2 （默认 1）
@param flags 标记 0（默认）
@throws SecurityException
@throws IOException

private native static FileDescriptor open(String path, int baudRate, int parity, int dataBits,

int stopBit, int flags);

public native void close();

static {

System.loadLibrary(“serial_port”);

}

使用javah生成.h头文件

https://huangxiaoguo.blog.youkuaiyun.com/article/details/94385612

编码c支持设置奇偶校验、数据位、停止位

在这里插入图片描述

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 <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 void throwException(JNIEnv *env, const char *name, const char *msg)

{

jclass cls = env->FindClass(name);

/* if cls is NULL, an exception has already been thrown */

if (cls != NULL) {

env->ThrowNew(cls, msg);

}

/* free the local ref */

env->DeleteLocalRef(cls);

}

extern “C”

JNIEXPORT jobject JNICALL Java_cn_yumakeji_lib_1serialportapi_SerialPort_open__Ljava_lang_String_2IIIII

(JNIEnv *env, jclass thiz, jstring path, jint baudrate,jint parity, jint dataBits, jint stopBit, jint flags)

{

int fd;

speed_t speed;

jobject mFileDescriptor;

/* Check arguments */

{

speed = getBaudrate(baudrate);

if (speed == -1) {

throwException(env, “java/lang/IllegalArgumentException”, “Invalid baudrate”);

return NULL;

}

if (parity <0 || parity>2) {

throwException(env, “java/lang/IllegalArgumentException”, “Invalid parity”);

return NULL;

}

if (dataBits <5 || dataBits>8) {

throwException(env, “java/lang/IllegalArgumentException”, “Invalid dataBits”);

return NULL;

}

if (stopBit <1 || stopBit>2) {

throwException(env, “java/lang/IllegalArgumentException”, “Invalid stopBit”);

return NULL;

}

/* Opening device */

{

jboolean iscopy;

const char *path_utf = env->GetStringUTFChars(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(path, path_utf);

if (fd == -1)

{

throwException(env, “java/io/IOException”, “Cannot open port”);

return NULL;

}

/* Configure device */

{

struct termios cfg;

LOGD(“Configuring serial port”);

if (tcgetattr(fd, &cfg))

{

LOGE(“tcgetattr() failed”);

close(fd);

throwException(env, “java/io/IOException”, “tcgetattr() failed”);

return NULL;

}

cfmakeraw(&cfg);

cfsetispeed(&cfg, speed);

cfsetospeed(&cfg, speed);

/* More attribute set */

switch (parity) {

case 0: break;

case 1: cfg.c_cflag |= PARENB; break;

case 2: cfg.c_cflag &= ~PARODD; break;

}

switch (dataBits) {

case 5: cfg.c_cflag |= CS5; break;

case 6: cfg.c_cflag |= CS6; break;

case 7: cfg.c_cflag |= CS7; break;

case 8: cfg.c_cflag |= CS8; break;

}

switch (stopBit) {

case 1: cfg.c_cflag &= ~CSTOPB; break;

case 2: cfg.c_cflag |= CSTOPB; break;

}

if (tcsetattr(fd, TCSANOW, &cfg))

{

LOGE(“tcsetattr() failed”);

close(fd);

/* TODO: throw an exception */

return NULL;

}

/* Create a corresponding file descriptor */

{

jclass cFileDescriptor = env->FindClass(“java/io/FileDescriptor”);

jmethodID iFileDescriptor = env->GetMethodID(cFileDescriptor, “”, “()V”);

jfieldID descriptorID = env->GetFieldID(cFileDescriptor, “descriptor”, “I”);

mFileDescriptor = env->NewObject(cFileDescriptor, iFileDescriptor);

env->SetIntField(mFileDescriptor, descriptorID, (jint)fd);

}

return mFileDescriptor;

}

Class: android_serialport_SerialPort
Method: open
Signature: (Ljava/lang/String;II)Ljava/io/FileDescriptor;

JNIEXPORT jobject JNICALL Java_cn_yumakeji_lib_1serialportapi_SerialPort_open__Ljava_lang_String_2II

(JNIEnv *env, jclass thiz, jstring path, jint baudrate, jint flags)

{

int fd;

speed_t speed;

jobject mFileDescriptor;

/* Check arguments */

{

speed = getBaudrate(baudrate);

if (speed == -1) {

/* TODO: throw an exception */

LOGE(“Invalid baudrate”);

return NULL;

}

/* Opening device */

{

jboolean iscopy;

const char *path_utf = env->GetStringUTFChars(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(path, path_utf);

if (fd == -1)

{

/* Throw an exception */

throwException(env, “java/io/IOException”, “Cannot open port”);

/* TODO: throw an exception */

return NULL;

}

/* Configure device */

{