#include <stdlib.h>
#include <unistd.h>
#include <android/log.h>
#include "gt.h"
#include "gterror.h"
#include "gttoolkitext.h"
#include "gttoolkit.h"
#include "gttoolerror.h"

int GtToolkitExt::swapError(int srcError)
{
    int result = 0;
    if(srcError == GtToolError::ERROR_TOOL_TIMEOUT)
    {
        result = GtError::ERROR_TIMEOUT;
    }
    else if(srcError == GtToolError::ERROR_TOOL_SELECT)
    {
        result = GtError::ERROR_SELECT;
    }
    else if(srcError == GtToolError::ERROR_TOOL_READ_FAILED)
    {
        result = GtError::ERROR_READ_FAILED;
    }
    else if(srcError == GtToolError::ERROR_TOOL_WRITE_FAILED)
    {
        result = GtError::ERROR_WRITE_FAILED;
    }
    else if(srcError == GtToolError::ERROR_TOOL_CLOSED)
    {
        result = GtError::ERROR_CLOSED;
    }
    else if(srcError == GtToolError::ERROR_TOOL_CREATE_SOCKET)
    {
        result = GtError::ERROR_CREATE_SOCKET;
    }
    else if(srcError == GtToolError::ERROR_TOOL_SET_SOCKET)
    {
        result = GtError::ERROR_SET_SOCKET;
    }
    else if(srcError == GtToolError::ERROR_TOOL_BIND_SOCKET)
    {
        result = GtError::ERROR_BIND_SOCKET;
    }
    else if(srcError == GtToolError::ERROR_TOOL_LISTEN_SOCKET)
    {
        result = GtError::ERROR_LISTEN_SOCKET;
    }
    else if(srcError == GtToolError::ERROR_TOOL_CONNECT_SOCKET)
    {
        result = GtError::ERROR_CONNECT_SOCKET;
    }
    else if(srcError == GtToolError::ERROR_TOOL_ACCEPT_SOCKET)
    {
        result = GtError::ERROR_ACCEPT_SOCKET;
    }
    else if(srcError == GtToolError::ERROR_TOOL_DIR_NOT_EXIST)
    {
        result = GtError::ERROR_DIR_NOT_EXIST;
    }
    else if(srcError == GtToolError::ERROR_TOOL_DIR_GET_CURRENT)
    {
        result = GtError::ERROR_DIR_GET_CURRENT;
    }
    else if(srcError == GtToolError::ERROR_TOOL_DIR_CREATE)
    {
        result = GtError::ERROR_DIR_CREATE;
    }
    else if(srcError == GtToolError::ERROR_TOOL_FILE_NOT_EXIST)
    {
        result = GtError::ERROR_FILE_NOT_EXIST;
    }
    else if(srcError == GtToolError::ERROR_TOOL_FILE_OPEN)
    {
        result = GtError::ERROR_FILE_OPEN;
    }
    else if(srcError == GtToolError::ERROR_TOOL_FILE_WRITE)
    {
        result = GtError::ERROR_FILE_WRITE;
    }
    else if(srcError == GtToolError::ERROR_TOOL_FILE_READ)
    {
        result = GtError::ERROR_FILE_READ;
    }
    else if(srcError == GtToolError::ERROR_TOOL_DL_OPEN)
    {
        result = GtError::ERROR_DL_OPEN;
    }
    else if(srcError == GtToolError::ERROR_TOOL_DL_SYM)
    {
        result = GtError::ERROR_DL_SYM;
    }
    else if(srcError == GtToolError::ERROR_TOOL_DL_INVOKE)
    {
        result = GtError::ERROR_DL_INVOKE;
    }
    else if(srcError == GtToolError::ERROR_TOOL_INVALID_FUNC_PARAM)
    {
        result = GtError::ERROR_INVALID_FUNC_PARAM;
    }
    else if(srcError == GtToolError::ERROR_TOOL_INVALID_VALUE)
    {
        result = GtError::ERROR_INVALID_VALUE;
    }
    else if(srcError == GtToolError::ERROR_TOOL_PARSE_FAILED)
    {
        result = GtError::ERROR_PARSE_FAILED;
    }
    else if(srcError == GtToolError::ERROR_TOOL_PARSE_FAILED)
    {
        result = GtError::ERROR_OVERFLOW;
    }
    else if(srcError == GtToolError::ERROR_TOOL_FORMAT)
    {
        result = GtError::ERROR_FORMAT;
    }
    else if(srcError == GtToolError::ERROR_TOOL_SEM_OP)
    {
        result = GtError::ERROR_SEM_OP;
    }
    else
    {
        result = GtError::ERROR_OTHER;
    }
    return result;
}

/************************************************************
*功能：获取接口版本
*输入：无
*输出：无
*返回：版本号（主版本 << 16 | 中间版本 << 8 | 小版本）
*/
int GtToolkitExt::version()
{
    return GtToolkit::version();
}

/************************************************************
*功能：获取全局唯一流水号（线程安全）
*输入：无
*输出：无
*返回：流水号
*/
unsigned long GtToolkitExt::uniqueSerialNumber()
{
    return GtToolkit::uniqueSerialNumber();
}

/************************************************************
*功能：超时等待
*输入：fd=文件句柄
*输入：timeout=超时时间（秒）
*输出：无
*返回：!=0错误
*/
int GtToolkitExt::waitFor(int fd, int timeout)
{
    int result = 0;

    result = GtToolkit::waitFor(fd, timeout);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：读取数据
*输入：fd=文件句柄
*输入：n=需要读取的数据长度
*输入：timeout=超时时间（秒）
*输出：data=读取到的数据
*返回：!=0错误
*/
ssize_t GtToolkitExt::readN(int fd, void *data, size_t n, int timeout)
{
    int result = 0;

    result = GtToolkit::readN(fd, data, n, timeout);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：写入数据
*输入：fd=文件句柄
*输入：data=需要写入的数据
*输入：n=需要写入的数据长度
*输入：timeout=超时时间（秒）
*输出：无
*返回：!=0错误
*/
ssize_t GtToolkitExt::writeN(int fd, const void *data, size_t n)
{
    int result = 0;

    result = GtToolkit::writeN(fd, data, n);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：字符串中获取第n-1到第n个分隔符之间的字符串
*输入：inStr=字符串
*输入：outBufLen=输出缓存大小
*输入：delimiter=分隔符
*输入：n=第n个分隔符（n>=1）
*输出：outStr=获取到的字符串
*返回：!=0错误
*/
int GtToolkitExt::parseNChar(char *inStr, char *outStr, int outBufLen, char delimiter, int n)
{
    int result = 0;

    result = GtToolkit::parseNChar(inStr, outStr, outBufLen, delimiter, n);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：字符串中获取第n-1到第n个分隔符之间的字符串
*输入：inStr=字符串
*输入：outBufLen=输出缓存大小
*输入：delimiter=分隔符字符串
*输入：n=第n个分隔符（n>=1）
*输出：outStr=获取到的字符串
*返回：!=0错误
*/
int GtToolkitExt::parseNString(char *inStr, char *outStr, int outBufLen, char* delimiter, int n)
{
    int result = 0;

    result = GtToolkit::parseNString(inStr, outStr, outBufLen, delimiter, n);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：字符串中获取第n个分隔符索引
*输入：inStr=字符串
*输入：delimiter=分隔符字符串
*输入：n=第n个分隔符（n>=1）
*输出：无
*返回：<0错误
*/
int GtToolkitExt::parseNCharIndex(char *inStr, char delimiter, int n)
{
    int result = 0;

    result = GtToolkit::parseNCharIndex(inStr, delimiter, n);
    if(result < 0)
    {
        return swapError(result);
    }
    return result;
}

/************************************************************
*功能：字符串排序
*输入：str=需排序字符串
*输入：n=需排序的个数
*输入：mode=[12]升序，[21]降序
*输出：无
*返回：!=0错误
*/
int GtToolkitExt::sortChar(unsigned char *str, int n, int mode)
{
    int result = 0;

    result = GtToolkit::sortChar(str, n, mode);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：X个选择Y个的组合数
*输入：x
*输入：y
*输出：无
*返回：组合数
*/
int GtToolkitExt::cXY(int x, int y)
{
    return GtToolkit::cXY(x, y);
}

/************************************************************
*功能：gbk编码转utf8编码
*输入：src=需转换的gbk编码字符串
*输入：inLen=需转换的gbk字符串长度
*输入：bufLen=转换utf8的缓存长度
*输出：des=转换为utf8的字符串
*输出：outLen=转换为utf8的字符串长度
*返回：!=0错误
*/
int GtToolkitExt::gbkToUtf8(char *src, int32_t inLen, char *des, int32_t bufLen, int *outLen)
{
    int result = 0;

    result = GtToolkit::gbkToUtf8(src, inLen, des, bufLen, outLen);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：utf8编码转gbk编码
*输入：src=需转换的utf8编码字符串
*输入：inLen=需转换的utf8字符串长度
*输入：bufLen=转换gbk的缓存长度
*输出：des=转换为gbk的字符串
*输出：outLen=转换为gbk的字符串长度
*返回：!=0错误
*/
int GtToolkitExt::utf8ToGbk(char *src, int32_t inLen, char *des, int32_t bufLen, int *outLen)
{
    int result = 0;

    result = GtToolkit::utf8ToGbk(src, inLen, des, bufLen, outLen);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：十六进制转可视字符
*输入：src=需转换十六进制值
*输入：length=需转换的长度
*输入：bufLen=转换后缓存长度
*输出：desBuf=转换后的字符串
*返回：!=0错误
*/
int GtToolkitExt::hexToStr(unsigned char *src, int length, char *desBuf, int bufLen)
{
    int result = 0;

    result = GtToolkit::hexToStr(src, length, desBuf, bufLen);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：十六进制字符串转十进制
*输入：src=需转换十六进制字符串
*输出：value=转换后的十进制值
*返回：!=0错误
*/
int GtToolkitExt::hexStrToInt(unsigned char *src, int *value)
{
    int result = 0;

    result = GtToolkit::hexStrToInt(src, value);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：可视字符转十六进制
*输入：src=需转换可视字符
*输入：length=需转换的长度
*输入：bufLen=转换后缓存长度
*输出：desBuf=转换后的字符串
*返回：!=0错误
*/
int GtToolkitExt::strToHex(unsigned char *src, int length, unsigned char *desBuf)
{
    int result = 0;

    result = GtToolkit::strToHex(src, length, desBuf);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：时间字符串转时间秒数
*输入：srcTime=需转换时间
*输入：format=转换前的时间格式（必须包含，yyyy,MM,dd,hh,mm,ss）
*输出：desTime=转换后的时间
*返回：!=0错误
*/
int GtToolkitExt::convertTime(char *srcTime, char *format, time_t *desTime)
{
    int result = 0;

    result = GtToolkit::convertTime(srcTime, format, desTime);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：日期转换
*输入：srcTime=需转换时间
*输入：format=需要转换的格式（yyyy-MM-dd,yyyy/MM/dd等）
*输出：des=转换后的时间
*返回：!=0错误
*/
int GtToolkitExt::formatDate(time_t srcTime, char *format, char *des)
{
    int result = 0;

    result = GtToolkit::formatDate(srcTime, format, des);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：日期时间转换
*输入：srcTime=需转换时间
*输入：format=需要转换的格式（yyyy-MM-dd hh:mm:ss,yyyy/MM/dd-hh:mm:ss等）
*输出：des=转换后的时间
*返回：!=0错误
*/
int GtToolkitExt::formatDateTime(time_t srcTime, char *format, char *des)
{
    int result = 0;

    result = GtToolkit::formatDateTime(srcTime, format, des);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：产生一个指定范围的随机数
*输入：min最小数（min >= 0）
*输入：max最大数（max >= 0）
*输出：无
*返回：随机数
*/
int GtToolkitExt::randomN(int min, int max)
{
    return GtToolkit::randomN(min, max);
}

/************************************************************
*功能：产生随机验证码
*输入：bufLen=缓存长度
*输出：buf=随机验证码（格式为：随机码;验证码）
*返回：无
*/
void GtToolkitExt::randomIdentifyingCode(char *buf, int bufLen)
{
    GtToolkit::randomIdentifyingCode(buf, bufLen);
}

/************************************************************
*功能：创建tcp协议socket
*输入：无
*输出：socketFd=已创建的socket句柄
*返回：!=0错误
*/
int GtToolkitExt::tcpSocket(int *socketFd)
{
    int result = 0;

    result = GtToolkit::tcpSocket(socketFd);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：TCP网络连接
*输入：socketFd=有效的socket句柄
*输入：ip=服务器ip地址
*输入：port=服务器端口
*输入：timeout=超时时间（秒）
*输出：无
*返回：!=0错误
*/
int GtToolkitExt::tcpConnect(int socketFd, char *ip, unsigned short port, int timeout)
{
    int result = 0;

    result = GtToolkit::tcpConnect(socketFd, ip, port, timeout);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：绑定并监听socket
*输入：socketFd=有效的socket句柄
*输入：listenSize=监听的队列大小
*输入：ip=监听的ip地址
*输入：port=监听的端口
*输出：无
*返回：!=0错误
*/
int GtToolkitExt::tcpListen(int socketFd, int listenSize, char *ip, unsigned short port)
{
    int result = 0;

    result = GtToolkit::tcpListen(socketFd, listenSize, ip, port);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：接受TCP网络连接请求
*输入：socketFd=监听的socket句柄
*输出：connectFd=新的socket句柄
*输出：connectIp=请求连接的ip地址
*返回：!=0错误
*/
int GtToolkitExt::tcpAccept(int socketFd, int *connectFd, char *connectIp)
{
    int result = 0;

    result = GtToolkit::tcpAccept(socketFd, connectFd, connectIp);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：文件是否存在
*输入：fileName=文件路径名称
*输出：无
*返回：=0文件存在，!=0文件不存在
*/
int GtToolkitExt::isFileExist(const char *fileName)
{
    int result = 0;

    result = GtToolkit::isFileExist(fileName);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：获取文件大小
*输入：fileName=文件路径名称
*输出：无
*返回：<0错误,>=0文件大小
*/
int GtToolkitExt::getFileSize(const char *fileName)
{
    int result = 0;

    result = GtToolkit::getFileSize(fileName);
    if(result < 0)
    {
        return swapError(result);
    }
    return result;
}

/************************************************************
*功能：文件目录是否存在
*输入：dirName=文件目录名称
*输出：无
*返回：=0目录存在，!=0目录不存在
*/
int GtToolkitExt::dirIsExist(char *dirName)
{
    int result = 0;

    result = GtToolkit::dirIsExist(dirName);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：获取当前目录
*输入：length=缓存长度
*输出：dirName=文件目录名称
*返回：!=0错误
*/
int GtToolkitExt::currentDir(char *dirName, int length)
{
    int result = 0;

    result = GtToolkit::currentDir(dirName, length);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：创建目录，默认属性为0744
*输入：dirName=文件目录名称
*输出：无
*返回：!=0错误
*/
int GtToolkitExt::mkDir(char *dirName)
{
    int result = 0;

    result = GtToolkit::mkDir(dirName);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：检查当前文件大小，如果超出制定大小，默认10M，则重命名当前文件后缀为.old保存
*输入：fileName=文件路径名称
*输入：size=文件限制大小（单位：M）
*输出：无
*返回：无
*/
void GtToolkitExt::limitFileSize(const char *fileName, int size)
{
    GtToolkit::limitFileSize(fileName, size);
}

/************************************************************
*功能：写文件并且同步到磁盘,覆盖写
*输入：fileName=文件路径名称
*输入：buf=写入内容
*输入：length=写入内容长度
*输出：无
*返回：!=0错误
*/
int GtToolkitExt::writeSyncFile(const char *fileName, const void *buf, int length)
{
    int result = 0;

    result = GtToolkit::writeSyncFile(fileName, buf, length);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：写文件，追加写
*输入：fileName=文件路径名称
*输入：buf=写入内容
*输入：length=写入内容长度
*输出：无
*返回：!=0错误
*/
int GtToolkitExt::appendWriteFile(const char *fileName, const void *buf, int length)
{
    int result = 0;

    result = GtToolkit::appendWriteFile(fileName, buf, length);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：清除文件并且同步到磁盘，置文件长度为0
*输入：fileName=文件路径名称
*输出：无
*返回：!=0错误
*/
int GtToolkitExt::truncateSyncIOFile(const char *fileName)
{
    int result = 0;

    result = GtToolkit::truncateSyncIOFile(fileName);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：读取文件内容
*输入：fileName=文件路径名称
*输入：length=读入内容长度
*输出：buf=读入内容
*返回：!=0错误
*/
int GtToolkitExt::readFile(const char *fileName, void *buf, int length)
{
    int result = 0;

    result = GtToolkit::readFile(fileName, buf, length);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：从指定文件读取指定属性
*输入：fileName=文件路径名称
*输入：attr=属性字段名称
*输出：str=属性字段值
*返回：!=0错误
*/
int GtToolkitExt::readAttrFromFile(const char *fileName, const char *attr, char *str)
{
    int result = 0;

    result = GtToolkit::readAttrFromFile(fileName, attr, str);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：写入指定字段值到文件
*输入：fileName=文件路径名称
*输入：attr=属性字段名称
*输入：str=写入的字段内容
*输出：无
*返回：!=0错误
*/
int GtToolkitExt::writeAttrCfgFile(const char *fileName, const char *attr, const char *str)
{
    int result = 0;

    result = GtToolkit::writeAttrCfgFile(fileName, attr, str);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：写交易日志文件
*输入：fileName=文件路径名称
*输入：log=写入日志内容
*输出：无
*返回：!=0错误
*/
int GtToolkitExt::tradingLogFile(const char *fileName, char *log, int logSize)
{
    int result = 0;

    result = GtToolkit::tradingLogFile(fileName, log, logSize);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：写错误日志文件
*输入：fileName=文件路径名称
*输入：tag=日志标签
*输入：line=行数
*输入：logStr=日志数据
*输出：无
*返回：!=0错误
*/
int GtToolkitExt::errorLogFile(const char *fileName, char *tag, char *logStr)
{
    int result = 0;

    result = GtToolkit::errorLogFile(fileName, tag, logStr);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：普通日志信息打印
*输入：tag=日志标签
*输入：str=日志信息
*输出：无
*返回：无
*/
void GtToolkitExt::logInfo(const char *fileName, const int line, const char *str, ...)
{
    char tag[256];
    char buf[5120];
    int length = 0;
    char *pstr = NULL;
    char *dest = NULL;
    va_list argList;

    memset(tag, 0, sizeof(tag));
    pstr = (char *)fileName;
    while(1)
    {
        pstr = strstr(pstr, "/");
        if(pstr == NULL)
        {
            break;
        }
        dest = pstr;
        pstr++;
    }
    memset(buf, 0, sizeof(buf));
    if(dest != NULL)
    {
        length = sprintf(buf, "☞(%s:%d) ", dest + 1, line);
    }
    else
    {
        length = sprintf(buf, "☞(%s:%d) ", fileName, line);
    }
    va_start(argList, str);
    vsprintf(&buf[length], str, argList);
    va_end(argList);
    __android_log_write(ANDROID_LOG_INFO, "GtLogger", buf);
}

/************************************************************
*功能：警告日志信息打印
*输入：tag=日志标签
*输入：str=日志信息
*输出：无
*返回：无
*/
void GtToolkitExt::logWarn(const char *fileName, const int line, const char *str, ...)
{
    char tag[256];
    char buf[5120];
    int length = 0;
    char *pstr = NULL;
    char *dest = NULL;
    va_list argList;

    memset(tag, 0, sizeof(tag));
    pstr = (char *)fileName;
    while(1)
    {
        pstr = strstr(pstr, "/");
        if(pstr == NULL)
        {
            break;
        }
        dest = pstr;
        pstr++;
    }
    memset(buf, 0, sizeof(buf));
    if(dest != NULL)
    {
        length = sprintf(buf, "☞(%s:%d) ", dest + 1, line);
    }
    else
    {
        length = sprintf(buf, "☞(%s:%d) ", fileName, line);
    }
    va_start(argList, str);
    vsprintf(&buf[length], str, argList);
    va_end(argList);
    __android_log_write(ANDROID_LOG_WARN, "GtLogger", buf);
}

/************************************************************
*功能：错误日志信息打印
*输入：tag=日志标签
*输入：str=日志信息
*输出：无
*返回：无
*/
void GtToolkitExt::logError(const char *fileName, const int line, const char *str, ...)
{
    char tag[256];
    char buf[5120];
    char path[256];
    int length = 0;
    char *pstr = NULL;
    char *dest = NULL;
    va_list argList;

    memset(tag, 0, sizeof(tag));
    pstr = (char *)fileName;
    while(1)
    {
        pstr = strstr(pstr, "/");
        if(pstr == NULL)
        {
            break;
        }
        dest = pstr;
        pstr++;
    }
    memset(buf, 0, sizeof(buf));
    if(dest != NULL)
    {
        length = sprintf(buf, "☞(%s:%d) ", dest + 1, line);
        sprintf(tag, "%s:%d", dest + 1, line);
    }
    else
    {
        length = sprintf(buf, "☞(%s:%d) ", fileName, line);
        sprintf(tag, "%s:%d", fileName, line);
    }
    va_start(argList, str);
    vsprintf(&buf[length], str, argList);
    va_end(argList);
    __android_log_write(ANDROID_LOG_ERROR, "GtLogger", buf);
    //保存日志文件
    Gt::instance()->getErrorLogFile(path);
    errorLogFile(path, tag, &buf[length]);
}

/************************************************************
*功能：信号量等待操作
*输入：name有名信号量
*输入：timeout等待超时时间
*输出：无
*返回：无
*/
int GtToolkitExt::semWait(char *name, int timeout)
{
    return GtToolkit::semWait(name, timeout);
}

/************************************************************
*功能：信号量等待操作
*输入：name有名信号量
*输入：timeout等待超时时间
*输出：无
*返回：无
*/
int GtToolkitExt::semPost(char *name)
{
    return GtToolkit::semPost(name);
}

/************************************************************
*功能：读取Assets目录文件
*输入：env=虚拟机环境
*输入：obj=AssetManager对象
*输入：fileName=文件名称
*输出：buf=数据
*输出：length=数据长度
*返回：!=0错误
*/
int GtToolkitExt::readAssetFile(JNIEnv *env, jobject obj, char *fileName, char *buf, int *length)
{
    int result = 0;

    result = GtToolkit::readAssetFile(env, obj, fileName, buf, length);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：读取Assets目录BMP文件，并转换成位图数据（buf空间需手动释放）
*输入：env=虚拟机环境
*输入：obj=AssetManager对象
*输入：fileName=文件名称
*输出：buf=图片数据
*输出：length=图片数据长度
*输出：width=图片宽度
*输出：height=图片高度
*返回：!=0错误
*/
int GtToolkitExt::readAssetBMP(JNIEnv *env, jobject obj, char *fileName, char **buf, int *length, int *width, int *height)
{
    int result = 0;

    result = GtToolkit::readAssetBMP(env, obj, fileName, buf, length, width, height);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：java对象中int字段转c int值
*输入：env=虚拟机环境
*输入：obj=java对象
*输入：tag=java对象需要转换的int类型字段名称
*输出：value=转换后的c int值
*返回：!=0错误
*/
int GtToolkitExt::jIntCInt(JNIEnv *env, jobject obj, char *tag, int *value)
{
    int result = 0;

    result = GtToolkit::jIntCInt(env, obj, tag, value);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：java对象中long字段转c long值
*输入：env=虚拟机环境
*输入：obj=java对象
*输入：tag=java对象需要转换的long类型字段名称
*输出：value=转换后的c long值
*返回：!=0错误
*/
int GtToolkitExt::jLongCLong(JNIEnv *env, jobject obj, char *tag, long *value)
{
    int result = 0;

    result = GtToolkit::jLongCLong(env, obj, tag, value);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：java对象中double字段转c double值
*输入：env=虚拟机环境
*输入：obj=java对象
*输入：tag=java对象需要转换的double类型字段名称
*输出：value=转换后的c double值
*返回：!=0错误
*/
int GtToolkitExt::jDoubleCDouble(JNIEnv *env, jobject obj, char *tag, double *value)
{
    int result = 0;

    result = GtToolkit::jDoubleCDouble(env, obj, tag, value);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：java对象中String字段转c char[]值
*输入：env=虚拟机环境
*输入：obj=java对象
*输入：tag=java对象需要转换的char[]类型字段名称
*输出：value=转换后的c char[]值
*返回：!=0错误
*/
int GtToolkitExt::jStringCCharArray(JNIEnv *env, jobject obj, char *tag, char *buf, int bufLen)
{
    int result = 0;

    result = GtToolkit::jStringCCharArray(env, obj, tag, buf, bufLen);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：java对象中String[]字段转c char[][]值
*输入：env=虚拟机环境
*输入：obj=java对象
*输入：tag=java对象需要转换的char[][]类型字段名称
*输出：buf=转换后的c char[][]值
*返回：!=0错误
*/
int GtToolkitExt::jStringArrayCCharArray2(JNIEnv *env, jobject obj, char *tag, char buf[][256])
{
    int result = 0;

    result = GtToolkit::jStringArrayCCharArray2(env, obj, tag, buf);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：java对象中byte[]字段转c char[]值
*输入：env=虚拟机环境
*输入：obj=java对象
*输入：tag=java对象需要转换的char[]类型字段名称
*输出：buf=转换后的c char[]值
*返回：!=0错误
*/
int GtToolkitExt::jByteArrayCCharArray(JNIEnv *env, jobject obj, char *tag, char *buf, int bufLen)
{
    int result = 0;

    result = GtToolkit::jByteArrayCCharArray(env, obj, tag, buf, bufLen);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：java对象中byte[][]字段转c char[][]值
*输入：env=虚拟机环境
*输入：obj=java对象
*输入：tag=java对象需要转换的char[][]类型字段名称
*输出：buf=转换后的c char[][]值
*返回：!=0错误
*/
int GtToolkitExt::jByteArray2CCharArray2(JNIEnv *env, jobject obj, char *tag, char buf[][256], int *outLen)
{
    int result = 0;

    result = GtToolkit::jByteArray2CCharArray2(env, obj, tag, buf, outLen);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：java对象中long[]字段转c long[]值
*输入：env=虚拟机环境
*输入：obj=java对象
*输入：tag=java对象需要转换的long[]类型字段名称
*输出：buf=转换后的c long[]值
*返回：!=0错误
*/
int GtToolkitExt::jLongArrayCLongArray(JNIEnv *env, jobject obj, char *tag, long *buf, int bufLen)
{
    int result = 0;

    result = GtToolkit::jLongArrayCLongArray(env, obj, tag, buf, bufLen);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：java对象中int[]字段转c int[]值
*输入：env=虚拟机环境
*输入：obj=java对象
*输入：tag=java对象需要转换的int[]类型字段名称
*输出：buf=转换后的c int[]值
*返回：!=0错误
*/
int GtToolkitExt::jIntArrayCIntArray(JNIEnv *env, jobject obj, char *tag, int *buf, int bufLen)
{
    int result = 0;

    result = GtToolkit::jIntArrayCIntArray(env, obj, tag, buf, bufLen);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：java对象中int[][]字段转c int[][]值
*输入：env=虚拟机环境
*输入：obj=java对象
*输入：tag=java对象需要转换的int[][]类型字段名称
*输出：buf=转换后的c int[][]值
*返回：!=0错误
*/
int GtToolkitExt::jIntArray2CIntArray2(JNIEnv *env, jobject obj, char *tag, int buf[][256], int *outLen)
{
    int result = 0;

    result = GtToolkit::jIntArray2CIntArray2(env, obj, tag, buf, outLen);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：c int 转 java对象中的int字段
*输入：env=虚拟机环境
*输入：tag=java对象需要赋值的int类型字段名称
*输入：value=c int值
*输出：obj=java对象
*返回：!=0错误
*/
int GtToolkitExt::cIntJInt(JNIEnv *env, jobject obj, char *tag, int value)
{
    int result = 0;

    result = GtToolkit::cIntJInt(env, obj, tag, value);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：c long 转 java对象中的long字段
*输入：env=虚拟机环境
*输入：tag=java对象需要赋值的long类型字段名称
*输入：value=c long值
*输出：obj=java对象
*返回：!=0错误
*/
int GtToolkitExt::cLongJLong(JNIEnv *env, jobject obj, char *tag, long value)
{
    int result = 0;

    result = GtToolkit::cLongJLong(env, obj, tag, value);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：c double 转 java对象中的double字段
*输入：env=虚拟机环境
*输入：tag=java对象需要赋值的double类型字段名称
*输入：value=c double值
*输出：obj=java对象
*返回：!=0错误
*/
int GtToolkitExt::cDoubleJDouble(JNIEnv *env, jobject obj, char *tag, double value)
{
    int result = 0;

    result = GtToolkit::cDoubleJDouble(env, obj, tag, value);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：c char[] 转 java对象中的String字段
*输入：env=虚拟机环境
*输入：tag=java对象需要赋值的String类型字段名称
*输入：value=c char[]值
*输出：obj=java对象
*返回：!=0错误
*/
int GtToolkitExt::cCharArrayJString(JNIEnv *env, jobject obj, char *tag, char *value)
{
    int result = 0;

    result = GtToolkit::cCharArrayJString(env, obj, tag, value);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：c char[] 转 java对象中的byte[]字段
*输入：env=虚拟机环境
*输入：tag=java对象需要赋值的byte[]类型字段名称
*输入：value=c char[]值
*输入：length=char[]缓存长度
*输出：obj=java对象
*返回：!=0错误
*/
int GtToolkitExt::cCharArrayJByteArray(JNIEnv *env, jobject obj, char *tag, char *value, int length)
{
    int result = 0;

    result = GtToolkit::cCharArrayJByteArray(env, obj, tag, value, length);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：c int[] 转 java对象中的int[]字段
*输入：env=虚拟机环境
*输入：tag=java对象需要赋值的int[]类型字段名称
*输入：value=c int[]值
*输入：length=缓存长度
*输出：obj=java对象
*返回：!=0错误
*/
int GtToolkitExt::cIntArrayJIntArray(JNIEnv *env, jobject obj, char *tag, int *value, int length)
{
    int result = 0;

    result = GtToolkit::cIntArrayJIntArray(env, obj, tag, value, length);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：c double[] 转 java对象中的double[]字段
*输入：env=虚拟机环境
*输入：tag=java对象需要赋值的double[]类型字段名称
*输入：value=c double[]值
*输入：length=缓存长度
*输出：obj=java对象
*返回：!=0错误
*/
int GtToolkitExt::cDoubleArrayJDoubleArray(JNIEnv *env, jobject obj, char *tag, double *value, int length)
{
    int result = 0;

    result = GtToolkit::cDoubleArrayJDoubleArray(env, obj, tag, value, length);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：c int[][] 转 java对象中的int[][]字段
*输入：env=虚拟机环境
*输入：tag=java对象需要赋值的int[][]类型字段名称
*输入：value=c int[][]值
*输入：size=一维缓存长度
*输入：length=二维缓存长度
*输出：obj=java对象
*返回：!=0错误
*/
int GtToolkitExt::cIntArray2JIntArray2(JNIEnv *env, jobject obj, char *tag, int value[][256], int size, int *length)
{
    int result = 0;

    result = GtToolkit::cIntArray2JIntArray2(env, obj, tag, value, size, length);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：c char[][] 转 java对象中的String[]字段
*输入：env=虚拟机环境
*输入：tag=java对象需要赋值的String[]类型字段名称
*输入：value=c char[][]值
*输入：size=一维缓存长度
*输出：obj=java对象
*返回：!=0错误
*/
int GtToolkitExt::cCharArray2CStringArray(JNIEnv *env, jobject obj, char *tag, char buf[][256], int size)
{
    int result = 0;

    result = GtToolkit::cCharArray2CStringArray(env, obj, tag, buf, size);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：对java Integer对象赋值
*输入：env=虚拟机环境
*输入：value=c int值
*输出：obj=java对象
*返回：!=0错误
*/
int GtToolkitExt::setJInt(JNIEnv *env, jobject obj, int value)
{
    int result = 0;

    result = GtToolkit::setJInt(env, obj, value);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：java String 转c char[]
*输入：env=虚拟机环境
*输入：obj=java String对象
*输入：bufLen=c char[]缓存长度
*输出：buf=c字符串
*返回：!=0错误
*/
int GtToolkitExt::jString2Char(JNIEnv *env, jstring obj, char *buf, int bufLen)
{
    int result = 0;

    result = GtToolkit::jString2Char(env, obj, buf, bufLen);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}

/************************************************************
*功能：java byte[] 转c char[]
*输入：env=虚拟机环境
*输入：obj=java byte[]对象
*输入：bufLen=c char[]缓存长度
*输出：buf=c字符串
*返回：!=0错误
*/
int GtToolkitExt::jByteArray2Char(JNIEnv *env, jbyteArray obj, char *buf, int bufLen)
{
    int result = 0;

    result = GtToolkit::jByteArray2Char(env, obj, buf, bufLen);
    if(result != 0)
    {
        return swapError(result);
    }
    return 0;
}