#include <jni.h>
#include <string>

#include "SpiPort.h"
#include "SpiLib.h"

#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <linux/spi/spidev.h>
#include <android/log.h>
#include <stdio.h>
#include <dirent.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <termios.h>
#include <time.h>
#include "GPIOControl.h"
#include "serialComm.h"
#include "SensorsProtocol.h"
#include "WeatherComm.h"

#if 0
#define BYTE u_char;
// 串口参数
typedef struct
{
    int		    baudrate;	/* 波特率*/
    int 		databit;	/* 数据位*/
    char		stopbit[8];	/* 停止位*/
    char		parity;		/* 校验位*/
    char		pathname[128];/* 串口文件名及路径*/
 } SERIAL_PARAM;

typedef struct
{
    int		    m_iRevStatus;	/* */
    int 		m_iRecvLen;	/* */
    int		    m_iNeedRevLength;	/* */
    int		    iRecvTime;		/* */
    int         RevCmdFlag;
    unsigned char	m_au8RecvBuf[128];/* */
} SIO_PARAM_SERIAL_DEF;

extern SIO_PARAM_SERIAL_DEF serialport;
extern float weatherpntmsg[10];
#endif

int istop=1;
//set_port_attr (int fd, int baudrate, int databit, const char *stopbit, char parity, int vtime, int vmin )
class NrsecSpiPort : public SpiPort {
public:
    NrsecSpiPort(const std::string& path) : SpiPort(path) {

    }

    bool Open()
    {
        if (!SpiPort::Open())
        {
            return false;
        }

        uint8_t mode = SPI_MODE_3;
        uint8_t bits = 8;
        uint32_t speed = 33000000;
        uint8_t lsb = 1;
        // const char *device = "/dev/spidev32766.1";

        if (ioctl(m_fd, SPI_IOC_WR_MODE, &mode) == -1 ||
            ioctl(m_fd, SPI_IOC_WR_BITS_PER_WORD, &bits) == -1 ||
            ioctl(m_fd, SPI_IOC_WR_MAX_SPEED_HZ, &speed) == -1 ||
            ioctl(m_fd, SPI_IOC_WR_LSB_FIRST, &lsb) == -1)
        {
            Close();
            return false;
        }

        return true;
    }
    bool GenKeyPair(int keyIdx) {
        unsigned char header[] = {0x80, 0xb2, 0x00, (unsigned char)keyIdx, 0x00 };

        int bytesWriten = Write(header, sizeof(header));
        unsigned char buffer[2] = { 0 };
        int bytesRead = Read(buffer, sizeof(buffer));
        if (bytesRead > 0) {
            int aa = 0;
        } else {
            int bb = 0;
        }

        return true;
    }
};

#if 0
static void set_baudrate (struct termios *opt, unsigned int baudrate)
{
    cfsetispeed(opt, baudrate);
    cfsetospeed(opt, baudrate);
}

static void set_data_bit (struct termios *opt, unsigned int databit)
{
    opt->c_cflag &= ~CSIZE;
    switch (databit)
    {
        case 8:
            opt->c_cflag |= CS8;
            break;
        case 7:
            opt->c_cflag |= CS7;
            break;
        case 6:
            opt->c_cflag |= CS6;
            break;
        case 5:
            opt->c_cflag |= CS5;
            break;
        default:
            opt->c_cflag |= CS8;
            break;
    }
}

static void set_parity (struct termios *opt, char parity)
{
    switch (parity)
    {
        case'N':/* 无校验 */
        case 'n':
            opt->c_cflag &= ~PARENB;
            break;
        case'E':/*偶校验*/
        case 'e':
            opt->c_cflag |= PARENB;
            opt->c_cflag &= ~PARODD;
            break;
        case'O':/* 奇校验 */
        case 'o':
            opt->c_cflag |= PARENB;
            opt->c_cflag |= ~PARODD;
            break;
        default: /*其它选择为无校验 */
            opt->c_cflag &= ~PARENB;
            break;
    }
}

static void set_stopbit (struct termios *opt, const char *stopbit)
{
    if (strcmp(stopbit, "1") == 0)
    {
        opt->c_cflag &= ~CSTOPB;/*1 位停止位 t */
    }
    else if(0 == strcmp(stopbit, "1.5"))
    {
        opt->c_cflag &= ~CSTOPB;/*1.5 位停止位 */
    }
    else if(0 == strcmp (stopbit,"2"))
    {
        opt->c_cflag |= CSTOPB; /*2 位停止位 */
    }
    else
    {
        opt->c_cflag &= ~CSTOPB; /*1 位停止位 */
    }
}

int set_port_attr (int fd, int baudrate, int databit, const char *stopbit, char parity, int vtime, int vmin )
{
    struct termios opt;
    tcgetattr(fd, &opt);
    set_baudrate(&opt, baudrate);
    //opt.c_cflag |= CLOCAL|CREAD; /*|CRTSCTS */
    opt.c_lflag &= ~(ICANON | ECHO |ECHOE |ISIG);
    set_data_bit(&opt, databit);
    set_parity(&opt, parity);
    set_stopbit(&opt, stopbit);
    opt.c_oflag = 0;
    //opt.c_lflag |= 0;
    opt.c_oflag &= ~OPOST;
    opt.c_cc[VTIME] = vtime;
    opt.c_cc[VMIN] = vmin;
    tcflush (fd, TCIFLUSH);
    return (tcsetattr (fd, TCSANOW, &opt));
}
#define MAX_STRING_LEN 32
#define IOT_PARAM_WRITE 0xAE
#define IOT_PARAM_READ 0xAF

typedef struct
{
    int cmd;
    int value;
    int result;
    long value2;
    char str[MAX_STRING_LEN];
}IOT_PARAM;

#define LOGE(fmt, args...) __android_log_print(ANDROID_LOG_ERROR, "serial_port_comm", fmt, ##args)
#endif
void setInt(int cmd, int value)
{
    int fd = open("/dev/mtkgpioctrl", O_RDONLY);
    IOT_PARAM param;
    param.cmd = cmd;
    param.value = value;
    // LOGE("set_int fd=%d,cmd=%d,value=%d\r\n",fd, cmd, value);
    if( fd > 0 )
    {
        int res = ioctl(fd, IOT_PARAM_WRITE, &param);
        // LOGE("set_int22 cmd=%d,value=%d,result=%d\r\n",param.cmd, param.value, param.result);
        close(fd);
    }
    return;
}
static void setRS485Enable(bool z) {
    setInt(CMD_SET_485_EN_STATE, z ? 1 : 0);
}

static void set485WriteMode() {
    setInt(CMD_SET_485_STATE, 1);
}


static void set485ReadMode() {
    setInt(CMD_SET_485_STATE, 0);
}
static void set12VEnable(bool z) {
    setInt(CMD_SET_12V_EN_STATE, z ? 1 : 0);
}

static void setCam3V3Enable(bool enabled)
{
    setInt(CMD_SET_CAM_3V3_EN_STATE, enabled ? 1 : 0);
}

static void InitPLZ()
{
    SENSOR_PARAM sensorParam[MAX_SERIAL_DEV_NUM];

    memset(sensorParam, 0, sizeof(sensorParam));
#if 0    //云台
    sensorParam[0].SensorsType = PELCO_D_PROTOCOL;
    sensorParam[0].baudrate = 9600;
    sensorParam[0].databit = 8;
    sensorParam[0].stopbit = 1;
    sensorParam[0].parity = 'n';
    sensorParam[0].IsNoInsta = 1;
    sensorParam[0].devaddr = 1;
    memset(sensorParam[0].pathname, 0, sizeof(sensorParam[0].pathname));
    sprintf(sensorParam[0].pathname, "/dev/ttyS0");
#else   //球基
    sensorParam[3].SensorsType = PELCO_D_PROTOCOL;
    sensorParam[3].baudrate = 38400;
    sensorParam[3].databit = 8;
    sensorParam[3].stopbit = 1;
    sensorParam[3].parity = 0;
    sensorParam[3].IsNoInsta = 1;
    //devparam[3].PowerPort = 15;
    sensorParam[3].CameraChannel = 1;
    sensorParam[3].devaddr = 0;
    memset(sensorParam[3].pathname, 0, sizeof(sensorParam[3].pathname));
    sprintf(sensorParam[3].pathname, "/dev/ttyS1");
#endif
    Gm_InitSerialComm(sensorParam, "/sdcard/photo/");
}
#if 0
static void setCam3V3Enable(bool enabled)
{
    setInt(CMD_SET_CAM_3V3_EN_STATE, enabled ? 1 : 0);
}

/*********************************************************************************
*						            气象数据处理							         *
**********************************************************************************/
void PortDataProcess( void )
{
    float			fvalue, fcorvalue, *fvalua, frnb/*, fwind*/;
    //WORD		uDevAddr;
    unsigned char		cmdidx;
    int			i, j, aipnt, datanum;
    SIO_PARAM_SERIAL_DEF	*pPortParam;
    char			szbuf[64];

    pPortParam = &serialport;
    //取出装置地址,开始处理地址+++
    if(0x02 == pPortParam->m_au8RecvBuf[5])
    {
        //pPortParam->devaddr = pPortParam->m_au8RecvBuf[4];
        return;
    }
    cmdidx = pPortParam->m_au8RecvBuf[5];
#if 0
    aipnt = pPortParam->SameTypeDevIdx;
    uDevAddr = serialport->m_au8RecvBuf[4];
    if(0 == srdt.IsReadWireTem)
    {
        if(uDevAddr != pPortParam->devaddr)
            return;
    }
#endif
    fvalua = &fvalue;
    datanum = pPortParam->m_au8RecvBuf[6];
    if((0x08 != cmdidx) && (0x09 != cmdidx))
        return;

    for(i = 0, j=7; (i<datanum) && (j<6+pPortParam->m_au8RecvBuf[1]); i++, j+=5 )
    {
        if(0x08 == cmdidx)
            fvalue = (pPortParam->m_au8RecvBuf[j+1]<<24)+(pPortParam->m_au8RecvBuf[j+2]<<16)
                     +(pPortParam->m_au8RecvBuf[j+3]<<8)+pPortParam->m_au8RecvBuf[j+4];
        else
        {
            *(u_char *)fvalua = pPortParam->m_au8RecvBuf[j+4];
            *((u_char *)fvalua+1) = pPortParam->m_au8RecvBuf[j+3];
            *((u_char *)fvalua+2) = pPortParam->m_au8RecvBuf[j+2];
            *((u_char *)fvalua+3) = pPortParam->m_au8RecvBuf[j+1];
        }
        switch(pPortParam->m_au8RecvBuf[j])
        {
            case	1:	/*温度*/
                weatherpntmsg[0] = fvalue;
                LOGE("温度:%0.3f  ", fvalue);
                break;
            case	2:	/*气压*/
                weatherpntmsg[5] = fvalue;
                LOGE("气压:%0.3f  ", fvalue);
                break;
            case	3:	/*湿度*/
                weatherpntmsg[1] = fvalue;
                LOGE("湿度:%0.3f  ", fvalue);
                break;
            case	4:	/*雨量*/
                break;
            case	5:	/*日照*/
                break;
            case	6:	/*风速*/
                weatherpntmsg[2] = fvalue;
                LOGE("风速:%0.3f  ", fvalue);
                break;
            case	7:	/*风向*/
                weatherpntmsg[3] = fvalue;
                LOGE("风向:%0.3f  ", fvalue);
                break;
            case	8:	/*拉力*/
            case	9:	/*倾角传感器X轴倾角*/
            case	10:	/*倾角传感器Y轴倾角*/
            case	11:	/*测温球导线温度*/
            case	12:	/*测温球内部温度*/
                break;
            case	13:	/*测温球导线X轴倾角*/
                break;
            case	14:	/*测温球导线Y轴倾角*/
                break;
            case	15:	/*测温球导线电流*/
                break;
            case	16:	/*测温球电池电压*/
                break;
            case	17: /*A相泄漏电流平均值；*/
                break;
            case	18: /*A相泄漏电流最大值；*/
                break;
            case	19: /*A相超过3mA的脉冲频次*/
                break;
            case	20: /*A相超过10mA的脉冲频次*/
                break;
            case	21: /*B相泄漏电流平均值；*/
                break;
            case	22: /*B相泄漏电流最大值；*/
                break;
            case	23: /*B相超过3mA的脉冲频次*/
                break;
            case	24: /*B相超过10mA的脉冲频次*/
            case	25: /*C相泄漏电流平均值；*/
            case	26: /*C相泄漏电流最大值；*/
            case	27: /*C相超过3mA的脉冲频次*/
            case	28: /*C相超过10mA的脉冲频次*/
                break;
        }
    }
}

//***************************************************************
//*    		     		按照协议格式化接收数据				*
//***************************************************************
void RecvData(u_char *buf, int len)// 规约读数据处理
{
    int  				i, ictime;
    //WORD				crc, check;
    SIO_PARAM_SERIAL_DEF	*pPortParam;

    pPortParam = &serialport;
    ictime = (int)time(NULL);

    if(pPortParam->m_iRecvLen == 0)
    {
        pPortParam->iRecvTime = ictime;
    }
    else
    {
        if((ictime-pPortParam->iRecvTime > 6) || (ictime - pPortParam->iRecvTime < 0))
            pPortParam->iRecvTime = ictime;
        else if(ictime - pPortParam->iRecvTime > 2)
        {
            pPortParam->m_iRecvLen = 0;
            pPortParam->m_iRevStatus = 0;
        }
    }

    for(i=0; i<len; i++)
    {
        switch(pPortParam->m_iRevStatus)
        {
            case 0:			// 0x68
                pPortParam->m_iRecvLen = 0;
                pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
                if(0x68 == buf[i])
                    pPortParam->m_iRevStatus++;
                else
                    pPortParam->m_iRevStatus = 18;
                break;
            case 1:			// len1
                pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
                pPortParam->m_iRevStatus++;
                break;
            case 2:			// len2
                pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
                if(buf[i] == pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen-2])
                {
                    pPortParam->m_iRevStatus++;
                    pPortParam->m_iNeedRevLength = buf[i]+5;
                }
                else
                    pPortParam->m_iRevStatus = 18;
                break;
            case 3:			// 0x68
                pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
                pPortParam->m_iNeedRevLength--;
                if(0x68 == buf[i])
                    pPortParam->m_iRevStatus++;
                else
                    pPortParam->m_iRevStatus = 18;
                break;
            case 4:	// 正确接收数据
                pPortParam->m_iNeedRevLength--;
                pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
                if(pPortParam->m_iNeedRevLength > 0)
                    break;
                if(buf[i] != 0x16)
                {
                    pPortParam->m_iRevStatus=18;
                    break;
                }

                //if(CheckLpcError(serialport->m_au8RecvBuf, pPortParam->m_iRecvLen) == TRUE)
                {
                    PortDataProcess();
                    pPortParam->m_iRevStatus = 0;
                    pPortParam->RevCmdFlag = 1;
                }
                 pPortParam->m_iRecvLen = 0;
                break;
            case 255:// 错误接收数据
            default:
                if(buf[i] == 0x68)
                {
                    pPortParam->m_iRevStatus = 1;
                    pPortParam->m_iRecvLen = 1;
                    pPortParam->m_au8RecvBuf[0] = buf[i];
                }
                else if(buf[i] == 0x16)
                {
                    pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
                    pPortParam->m_iRevStatus = 0;
                    pPortParam->m_iRecvLen = 0;
                }
                else
                {
                    pPortParam->m_au8RecvBuf[pPortParam->m_iRecvLen++] = buf[i];
                    if(pPortParam->m_iRecvLen > 200)
                    {
                        pPortParam->m_iRecvLen = 0;
                    }
                }
                break;
        }
    }
}

//int inum =0;
//int itimecnt=0;
int weather_comm(SERIAL_PARAM weatherport)
{
    int fd = -1;
    int len, i,ret, ictime, iruntime, isendtime, irecvtime, icnt=0;
    unsigned char sendbuf[] = {0x68,0x00,0x00,0x68,0x01,0x09,0x0a,0x16};
    char recvbuf[256], szbuf[512];
    //char serial_description[] = "/dev/ttyS0";

#if 0
    DIR *dir = opendir("/dev");
    if (dir == NULL) {
        LOGE("_test_ opendir");
        return -1;
    }

    // 读取目录项
    struct dirent *entry;
    while ((entry = readdir(dir)) != NULL) {
        // 过滤出串口设备，通常以"ttyS"或"ttyUSB"开头
        if ((strncmp(entry->d_name, "ttyS2", 5) == 0) ||
            (strncmp(entry->d_name, "ttyS0", 5) == 0)) {
            LOGE("_test_ Found serial port: %s\n", entry->d_name);
        }
    }

    // 关闭目录
    closedir(dir);
#endif
    serialport.RevCmdFlag = 1;
    serialport.m_iRecvLen = 0;
    serialport.m_iRevStatus = 0;

    set12VEnable(true);
    setCam3V3Enable(true);
    setRS485Enable(true);

    ictime = (int)time(NULL);
    for(;;)
    {
        if(fd < 0)
        {
            fd = open(weatherport.pathname, O_RDWR | O_NDELAY);
            //fd = open(weatherport.pathname, O_RDWR | O_NOCTTY);
            if(fd < 0)
            {
                LOGE("_test_ open serial error \n");
                perror(weatherport.pathname);
                return -1;
            }

            ret= set_port_attr (fd, weatherport.baudrate,weatherport.databit,weatherport.stopbit,weatherport.parity,0,0 );/*9600 8n1 */
            if(ret < 0)
            {
                LOGE("_test_ set uart arrt faile \n");
                return -1;
            }
        }

        usleep(10000);
        iruntime = (int)time(NULL);
        if((iruntime - ictime > 120) || (iruntime - ictime < 0))
            ictime = iruntime;
        if(iruntime - ictime > 19)
        {
            memset(szbuf, 0, sizeof(szbuf));
            sprintf(szbuf, "气象采样时间=%d,停止采样!", iruntime-ictime);
            LOGE("%s", szbuf);
            break;
        }

        if(1 == serialport.RevCmdFlag)
        {
            set485WriteMode();

            len = write(fd, sendbuf, sizeof(sendbuf));/* 向串囗发送字符串 */
            serialport.RevCmdFlag = 0;
            isendtime = time(NULL);
            if (len < 0) {
                LOGE("write data error \n");
                return -1;
            } else {
                memset(szbuf, 0, sizeof(szbuf));
                sprintf(szbuf, "Send：");
                for (i = 0; i < len; i++) {
                    sprintf(szbuf, "%s %02X", szbuf, sendbuf[i]);
                }
                LOGE("%s", szbuf);
                //icnt = 0;
                //inum++;
            }
            tcdrain(fd);
            //usleep(50000);
        }
        else
        {
            irecvtime = time(NULL);
            if((irecvtime-isendtime > 6) ||(irecvtime - isendtime < 0))
                isendtime = irecvtime;
            if (irecvtime-isendtime > 1)
            {
                LOGE("传感器超过%d秒未应答", irecvtime-isendtime);
                serialport.RevCmdFlag = 1;
                serialport.m_iRecvLen = 0;
                serialport.m_iRevStatus = 0;
                close(fd);
                //set12VEnable(false);
                //setCam3V3Enable(false);
                //setRS485Enable(false);
                fd = -1;
                continue;
            }
        }
        set485ReadMode();
        memset(recvbuf, 0, sizeof(recvbuf));
        len = read(fd, recvbuf, sizeof(recvbuf));/* 在串口读取字符串 */
        if (len < 0) {
            LOGE("serial read error \n");
            continue;
        }
        if(0 == len)
        {
            //icnt++;
            continue;
        }

        memset(szbuf, 0, sizeof(szbuf));
        sprintf(szbuf, "Recv：");
        for (i = 0; i < len; i++) {
            sprintf(szbuf, "%s %02X", szbuf, recvbuf[i]);
        }
        __android_log_print(ANDROID_LOG_INFO, "serial", "%s", szbuf);
        RecvData((u_char*)recvbuf, len);
        //LOGE("一周期空循环次数%d, 读取次数%d, 时间：%d %d", icnt, inum, (int)time(NULL), itimecnt);
        icnt = 0;
        //serialport.RevCmdFlag =1;
    }

    close(fd);
    set12VEnable(false);
    setCam3V3Enable(false);
    setRS485Enable(false);

    //exit(-1);
    return(0);
}

int serial_port_comm()
{
    SERIAL_PARAM  portparm;
#if 1
    memset(portparm.pathname, 0, sizeof(portparm.pathname));
    sprintf(portparm.pathname, "/dev/ttyS0");
    portparm.parity = 'N';
    portparm.databit = 8;
    portparm.baudrate = B9600;
    memset(portparm.stopbit, 0, sizeof(portparm.stopbit));
    sprintf(portparm.stopbit, "1");
#endif
    //itimecnt = (int)time(NULL);

    for(;;)
        weather_comm(portparm);
    return 0;
}
#endif


extern "C" JNIEXPORT jstring JNICALL
Java_com_xinyingpower_testcomm_MainActivity_testSpi(
        JNIEnv* env,
        jobject /*this*/, jint port) {
    //testSpi();
    SpiLIb a;
    unsigned char newkey[32]={0xaf,0x0c,0xa9,0x40,0x1f,0xe6,0xee,0x0f,0x4c,
                                     0xfb,0xf7,0x17,0x71,0xde,0x61,0x59
                                     ,0x0a,0x05,0x77,
                                     0xfa,0xe7,0xd1,0x8d,0x10,0x3a,0x79,0x23,0xf2,0xb3,
                                     0x6d,0xea,0x8e
//                                     ,0xe0,0x64,0xe7,0x5d,0x49,0x84,0xe4,
//                                     0x5f,0xc9,0x07,0x03,0x52,0x33,0x79,0x87,0xd4,0x62,
//                                     0x62,0xc0,0xcc,0xf0,0xd6,0x85,0x20,0x7f,0x7a,0xe8,
//                                     0xc8,0xed,0x12,0xdb,0xdc
    };
    unsigned char outpub[32],outsign[64], *outen = new unsigned char [256];
    unsigned char pucid[16]={0x01,0x01,0x01,0x01,0x01,0x01,0x01,
                             0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01};
    string b="C=CN,ST=jiangsu,L=nanjing,O=GDD,OU=nari,CN=test001";
    //a.SM2keypair(0x00);
    //a.SM3Hash(newkey,16, outpub);
    //a.sm3hash_tosm2(newkey,16,outpub,newkey,pucid,16);
    //a.SM2Sign(0x00,outpub,outsign);
    //a.SM2VerifySign(0x00,outpub,outsign);
    //if(i < wen, i++)
    //lxy modify modify
    //LOGE("_test_ setRS485Enable true");
    //setRS485Enable(true);

    //set12VEnable(true);
    //serial_port_comm();
    //GM_StartSerialComm();
    testComm();
    //GM_StartSerialCameraPhoto(1, 0);
    //lxy modify modify
    //LOGE("_test_ setRS485Enable false");
    //setRS485Enable(false);
    return env->NewStringUTF("");

#if 0
    DIR *dir = opendir("/dev");
    if (dir == NULL) {
        perror("opendir");
        //return env->NewStringUTF("error");
        //return -1;
    }

    // 读取目录项
    struct dirent *entry;
    while ((entry = readdir(dir)) != NULL) {
        // 过滤出串口设备，通常以"ttyS"或"ttyUSB"开头
        if ((strncmp(entry->d_name, "ttyS2", 5) == 0) ||
            (strncmp(entry->d_name, "ttyS0", 5) == 0)) {
            printf("Found serial port: %s\n", entry->d_name);
        }
    }

    // 关闭目录
    closedir(dir);
#endif
    a.SM2cert(0x00,0x00,b,outen);
    for (int i = 0; i < 32; i++) {
        //sprintf(output, " %02x ", rxbuf[i]);
        __android_log_print(ANDROID_LOG_INFO, "SPi", "%02x", outen[i]);
    }
//    a.SM2decoder(0x00,outen,outpub);
//
//    for (int i = 0; i < 64; i++) {
//        //sprintf(output, " %02x ", rxbuf[i]);
//        __android_log_print(ANDROID_LOG_INFO, "SPi", "%02x", outpub[i]);
//    }

    //a.SM3Hash(0x00,0x10,newkey);
    //testVersion();

    return env->NewStringUTF("End");

    // NrsecSpiPort spi("/dev/mtkgpioctrl");
    NrsecSpiPort spi("/dev/spidevSE");

    // NrsecSpiPort spi("/dev/spidev0.0");

    if (!spi.Open()) {
        return env->NewStringUTF(spi.GetLog().c_str());
    }

    spi.GenKeyPair(0);

    unsigned char header[] = { 0x00, 0x5b, 0x00, 0x00, 0x40 };

    int bytesWriten = spi.Write(header, sizeof(header));
    unsigned char buffer[1024] = { 0 };
    int bytesRead = spi.Read(buffer, 1);
    if (bytesRead > 0) {
        int aa = 0;
    } else {
        int bb = 0;
    }
    int len = buffer[0];
    bytesRead += spi.Read(&buffer[1], len);

    spi.Close();

    std::string result;
    char buf[32] = { 0 };
    for (int idx = 0; idx < 32; idx++)
    {
        sprintf(buf, "%X ", buffer[idx]);
        result += buf;
    }



    return env->NewStringUTF(result.c_str());
}

extern "C" JNIEXPORT void JNICALL
Java_com_xinyingpower_testcomm_MainActivity_setInt(
        JNIEnv* env,
        jobject /*this*/, jint cmd, jint val) {
    setInt(cmd, val);
}

extern "C" JNIEXPORT void JNICALL
Java_com_xinyingpower_testcomm_MainActivity_turnOn(
        JNIEnv* env,
        jobject /*this*/) {
    setRS485Enable(true);
    set12VEnable(true);
    setCam3V3Enable(true);
    setInt(CMD_SET_485_ENABLE, 1);
    setInt(CMD_SET_3V3_PWR_ENABLE, 1);
    setInt(CMD_SET_PTZ_PWR_ENABLE, 1);
    setInt(CMD_SET_PIC1_POWER, 1);
    setInt(CMD_SET_485_en4, 1);
    InitPLZ();
}


extern "C" JNIEXPORT void JNICALL
Java_com_xinyingpower_testcomm_MainActivity_turnOff(
        JNIEnv* env,
        jobject /*this*/) {
    setRS485Enable(false);
    set12VEnable(false);
    setCam3V3Enable(false);
    setInt(CMD_SET_485_ENABLE, 0);
    setInt(CMD_SET_3V3_PWR_ENABLE, 0);
    setInt(CMD_SET_PTZ_PWR_ENABLE, 0);
    setInt(CMD_SET_PIC1_POWER, 0);
    setInt(CMD_SET_485_en4, 0);
}

extern "C" JNIEXPORT void JNICALL
Java_com_xinyingpower_testcomm_MainActivity_turnLeft(
        JNIEnv* env,
        jobject /*this*/) {
    CameraPhotoCmd(0, 1, MOVE_LEFT, 0, 0);
}

extern "C" JNIEXPORT void JNICALL
Java_com_xinyingpower_testcomm_MainActivity_turnRight(
        JNIEnv* env,
        jobject /*this*/) {
    CameraPhotoCmd(0, 1, MOVE_RIGHT, 0, 0);
}

extern "C" JNIEXPORT void JNICALL
Java_com_xinyingpower_testcomm_MainActivity_turnUp(
        JNIEnv* env,
        jobject /*this*/) {
    CameraPhotoCmd(0, 1, MOVE_UP, 0, 0);
}

extern "C" JNIEXPORT void JNICALL
Java_com_xinyingpower_testcomm_MainActivity_turnDown(
        JNIEnv* env,
        jobject /*this*/) {
    CameraPhotoCmd(0, 1, MOVE_DOWN, 0, 0);
}

extern "C" JNIEXPORT void JNICALL
Java_com_xinyingpower_testcomm_MainActivity_zoomIn(
        JNIEnv* env,
        jobject /*this*/) {
    CameraPhotoCmd(0, 1, ZOOM_TELE, 0, 0);
}

extern "C" JNIEXPORT void JNICALL
Java_com_xinyingpower_testcomm_MainActivity_zoomOut(
        JNIEnv* env,
        jobject /*this*/) {
    CameraPhotoCmd(0, 1, ZOOM_WIDE, 0, 0);
}

extern "C" JNIEXPORT void JNICALL
Java_com_xinyingpower_testcomm_MainActivity_setSpeed(
        JNIEnv* env,
        jobject /*this*/, jint speed) {

}

extern "C" JNIEXPORT void JNICALL
Java_com_xinyingpower_testcomm_MainActivity_setPreset(
        JNIEnv* env,
        jobject /*this*/, jint preset) {
    CameraPhotoCmd(0, 1, SAVE_PRESETNO, 0, preset);
}

extern "C" JNIEXPORT void JNICALL
Java_com_xinyingpower_testcomm_MainActivity_gotoPreset(
        JNIEnv* env,
        jobject /*this*/, jint preset) {
    CameraPhotoCmd(0, 1, MOVE_PRESETNO, 0, preset);
}

extern "C" JNIEXPORT void JNICALL
Java_com_xinyingpower_testcomm_MainActivity_turnOnWipers(
        JNIEnv* env,
        jobject /*this*/) {

}

extern "C" JNIEXPORT void JNICALL
Java_com_xinyingpower_testcomm_MainActivity_turnOffWipers(
        JNIEnv* env,
        jobject /*this*/) {

}


extern "C" JNIEXPORT void JNICALL
Java_com_xinyingpower_testcomm_MainActivity_turnOnLight(
        JNIEnv* env,
        jobject /*this*/) {

}

extern "C" JNIEXPORT void JNICALL
Java_com_xinyingpower_testcomm_MainActivity_turnOffLight(
        JNIEnv* env,
        jobject /*this*/) {

}



///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////   lxy add
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#if 0
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;
    }
}
char* jstring2str(JNIEnv* env, jstring jstr)
{
    char*   rtn   =   NULL;
    jclass   clsstring   =   env->FindClass("java/lang/String");
    jstring   strencode   =   env->NewStringUTF("UTF-8");
    jmethodID   mid   =   env->GetMethodID(clsstring,   "getBytes",   "(Ljava/lang/String;)[B");
    jbyteArray   barr=   (jbyteArray)env->CallObjectMethod(jstr,mid,strencode);
    jsize   alen   =   env->GetArrayLength(barr);
    jbyte*   ba   =   env->GetByteArrayElements(barr,JNI_FALSE);

    if(alen > 0)
    {
        rtn = (char*)malloc(alen+1); //new char[alen+1];
        memcpy(rtn,ba,alen);
        rtn[alen] = 0;
    }

    env->ReleaseByteArrayElements(barr,ba,0);
    return  (char*)rtn;
}


int g_fd = -1;
int serial_open(char *devPath, speed_t baudrate ) {
    int ret = 0;
    setRS485Enable(true);
    int fd = open("/dev/ttyS0", O_RDWR |O_NOCTTY |O_NONBLOCK);
    LOGE("_test_ serial_open fd=%d \n",fd);
    if(fd < 0)
    {
        LOGE("_test_ open serial error \n");
        return 0;
    }
    //ret= set_port_attr (fd, baudrate,8,"1",'N',150,0 );/*9600 8n1 */
    ret= set_port_attr (fd, baudrate,8,"1",'N',150,0 );/*9600 8n1 */
    if(ret < 0)
    {
        LOGE("_test_ set serial param fail \n");
        return 0;
    }
    g_fd = fd;
    return 1;
}

void serial_close()
{
    LOGE("_test_ serial_close fd=%d \n",g_fd);
    if(g_fd != -1)
    {
        close(g_fd);
        setRS485Enable(false);
    }
    g_fd = -1;
}

int serial_write(char *sendbuf, int length)
{
    int len = 0;
    if(g_fd < 0)
        return 0;
    set485WriteMode();
    len = write(g_fd, sendbuf, length);/* 向串囗发送字符串 */
    LOGE("_test_ serial_write len=%d \n",len);
    if (len < 0)
    {
        LOGE("_test_ write data error \n");
        return 0;
    }
    return len;
}

int serial_read(char *readbuf,int length)
{
    int len = 0;
    if(g_fd < 0)
        return 0;
    set485ReadMode();
    memset(readbuf, 0, length);
    len = read(g_fd, readbuf, length);/* 在串口读取字符串 */
    LOGE("_test_ serial_read len=%d \n",len);
    if (len < 0)
    {
        //LOGE("_test_ read error \n");
        return 0;
    }
    return len;
}

extern "C" JNIEXPORT jboolean JNICALL Java_com_xinyingpower_testcomm_MainActivity_openSerial
(JNIEnv* env, jobject, jstring dev, jint baudrate) {
    char *devPath = jstring2str(env, dev);
    LOGE("_test open serial path=%s, baudrate=%d\n", devPath, baudrate);
    speed_t speed = getBaudrate(baudrate);
    int res = serial_open(devPath, speed);
    return res == 1 ? JNI_TRUE: JNI_FALSE;
}

extern "C" JNIEXPORT void JNICALL Java_com_xinyingpower_testcomm_MainActivity_closeSerial
        (JNIEnv* env, jobject) {
    serial_close();
}

extern "C" JNIEXPORT jint JNICALL Java_com_xinyingpower_testcomm_MainActivity_writeSerial
        (JNIEnv *env, jobject , jbyteArray jstr) {
    jsize len = env->GetArrayLength(jstr);
    if (len <= 0)
        return 0;
    jbyte *jdata = env->GetByteArrayElements(jstr, 0);
    int res = serial_write((char*)jdata, len);
    env->ReleaseByteArrayElements(jstr, jdata, 0);
    return res;
}

extern "C" JNIEXPORT jint JNICALL Java_com_xinyingpower_testcomm_MainActivity_readSerial
        (JNIEnv *env, jobject, jbyteArray out)
{
    jsize outlen = env->GetArrayLength(out);
    //LOGE("_test readSerial outlen=%d\n", outlen);
    if(outlen <= 0)
        return 0;
    jbyte* outData = env->GetByteArrayElements(out, 0);
    char* outbuf = (char*)outData;
    int res = serial_read(outbuf, outlen);
    //LOGE("_test serial_read res=%d\n", res);
    env->ReleaseByteArrayElements(out, outData, 0);
    return res;
}
#endif