619 lines
24 KiB
C++
619 lines
24 KiB
C++
#include <jni.h>
|
|
#include <opencv2/opencv.hpp>
|
|
#include <string>
|
|
#include <iostream>
|
|
#include <vector>
|
|
#include "base64.h"
|
|
#include <string>
|
|
#include <stdlib.h>
|
|
#include <mutex>
|
|
#include <HG_SCANNER_API.h>
|
|
#include <map>
|
|
#ifdef _WIN32
|
|
#include <io.h>
|
|
#else
|
|
#include <sys/uio.h>
|
|
//#include <sys/io.h>
|
|
#endif // linux
|
|
|
|
|
|
|
|
#include "utlis.h"
|
|
#if defined(WIN32)||defined(_WIN32)
|
|
#include <Windows.h>
|
|
#else
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#endif // defined(WIN32)||defined(_WIN32)
|
|
|
|
static jobject mUserListener = nullptr;
|
|
static jobject mUserCallback = nullptr;
|
|
static JavaVM* g_vm = nullptr;
|
|
HG_Scanner_Handle mScanner = nullptr;
|
|
static jobject gClassLoader;
|
|
static jmethodID gFindClassMethod;
|
|
static jclass statusClazz;
|
|
int indeximg = 0;
|
|
static int indexPatch = 0;
|
|
#define EN_LOG
|
|
|
|
#ifdef EN_LOG
|
|
#define LOG printf
|
|
#else
|
|
#define LOG
|
|
#endif // EN_LOG
|
|
|
|
std::mutex m_mutex;
|
|
|
|
static HG_CACHEIMGFORMAT m_cacheimgformat = HG_CJPG;
|
|
|
|
static std::map< HG_CACHEIMGFORMAT, std::string> m_mapcaches = {
|
|
{HG_CJPG,".jpg"},
|
|
{HG_CPNG,".png"},
|
|
{HG_CBMP,".bmp"},
|
|
{HG_CTIFF,".tiff"}
|
|
};
|
|
|
|
int writeimage(const char* filename, std::vector<unsigned char>& imagedata) {
|
|
FILE* fp = NULL;
|
|
if (NULL == imagedata.data() || imagedata.size() <= 0) return -1;
|
|
fp = fopen(filename, "wb"); // 必须确保是以 二进制写入的形式打开
|
|
|
|
if (NULL == fp)
|
|
return (-1);
|
|
|
|
fwrite(imagedata.data(), imagedata.size(), 1, fp); //二进制
|
|
fclose(fp);
|
|
fp = NULL;
|
|
return 0;
|
|
}
|
|
|
|
void onReceivedImage(HG_IMG* img, void* obj)
|
|
{
|
|
std::lock_guard<std::mutex> lock(m_mutex);
|
|
LOG("JAVA--- Enter onReceivedImage width:%d height:%d bitdepth:%d pdata:%p byteperlin:%d\n", img->width, img->height, img->bitdepth, img->pimgdata, img->bytesperline);
|
|
if (mUserCallback)
|
|
{
|
|
JNIEnv* env;
|
|
jint ret = g_vm->GetEnv((void**)&env, JNI_VERSION_1_6);
|
|
if (ret < 0)
|
|
g_vm->AttachCurrentThread((void**)&env, NULL);
|
|
|
|
jclass clazz = env->GetObjectClass(mUserCallback);
|
|
indeximg++;
|
|
indexPatch++;
|
|
cv::Mat matimg(img->height, img->width, img->bitdepth == 24 ? CV_8UC3 : CV_8UC1, img->pimgdata);
|
|
std::string filename, path, str_encodeformat;
|
|
std::vector<int> encodeparam;
|
|
if (m_mapcaches.count(m_cacheimgformat) > 0)
|
|
{
|
|
str_encodeformat = m_mapcaches[m_cacheimgformat];
|
|
switch (m_cacheimgformat)
|
|
{
|
|
case HG_CJPG:
|
|
encodeparam.push_back(CV_IMWRITE_JPEG_QUALITY);
|
|
encodeparam.push_back(70);
|
|
break;
|
|
case HG_CPNG:
|
|
encodeparam.push_back(CV_IMWRITE_PNG_STRATEGY);
|
|
encodeparam.push_back(cv::IMWRITE_PNG_STRATEGY_FIXED);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
str_encodeformat = m_mapcaches[HG_CJPG];
|
|
|
|
filename = std::to_string(indeximg) + str_encodeformat;
|
|
#if defined(WIN32) || defined(_WIN32)
|
|
WCHAR outapth[MAX_PATH];
|
|
auto length = GetTempPathW(MAX_PATH, outapth);
|
|
if (length < 1)
|
|
{
|
|
LOG("JAVA--- error : on Get tmpPath! this would cause no image be saved\n ");
|
|
path = "C:\\" + filename;//save in the system disk
|
|
}
|
|
else
|
|
{
|
|
path = WChar2Ansi(outapth);
|
|
path += filename;
|
|
}
|
|
#else
|
|
std::string dstdirPath = "/tmp/huagowebserver";
|
|
if (access(dstdirPath.c_str(), 0) == -1)//is not exist
|
|
{
|
|
int flag = mkdir(dstdirPath.c_str(), 0755);
|
|
if (flag != 0)
|
|
{
|
|
std::cout << "make " << dstdirPath << " falied" << std::endl;
|
|
dstdirPath = "/tmp";
|
|
}
|
|
}
|
|
path = dstdirPath + "/" + filename;
|
|
#endif
|
|
//std::vector<int> quality;
|
|
//quality.push_back(CV_IMWRITE_JPEG_QUALITY);
|
|
//quality.push_back(70);//进行50%的压缩
|
|
std::vector<unsigned char> data;
|
|
//cv::imencode(".jpg", matimg, data, quality);
|
|
data.insert(data.end(), img->pimgdata, img->pimgdata + img->bufferlength);
|
|
auto retw = writeimage(path.c_str(), data);
|
|
if (retw == -1)
|
|
LOG("JAVA--- LOST IMAGE %s \n", path.c_str());
|
|
|
|
std::string datastr(data.begin(), data.end());
|
|
if (!data.empty())
|
|
{
|
|
std::string base64data = base64_encode_mime(datastr);
|
|
jmethodID id = env->GetMethodID(env->GetObjectClass(mUserCallback), "onImageReceived", "(ILjava/lang/String;Ljava/lang/String;)V");
|
|
LOG("JAVA--- IMAGE PATH =%s \n", path.c_str());
|
|
env->CallVoidMethod(mUserCallback, id, indexPatch, env->NewStringUTF(path.c_str()), env->NewStringUTF(base64data.c_str()));
|
|
}
|
|
else
|
|
LOG("JAVA--- Get uncorrect data");
|
|
|
|
if (ret < 0)
|
|
g_vm->DetachCurrentThread();
|
|
}
|
|
else
|
|
LOG("JAVA--- mUserCallback is null\n");
|
|
}
|
|
|
|
//aaa
|
|
void onEvent(HG_STATUSCODE statuscode, void* obj) {
|
|
std::lock_guard<std::mutex> lock(m_mutex);
|
|
if (statuscode <= 0 || statuscode > 13)
|
|
return;
|
|
if (mUserListener) {
|
|
JNIEnv* env;
|
|
jint ret = g_vm->GetEnv((void**)&env, JNI_VERSION_1_6);
|
|
if (ret < 0)
|
|
jint ret2 = g_vm->AttachCurrentThread((void**)&env, NULL);
|
|
|
|
jclass listenerClazz = env->GetObjectClass(mUserListener);
|
|
jmethodID methodEventId = env->GetMethodID(listenerClazz, "onEvent", "(I)V");
|
|
env->CallVoidMethod(mUserListener, methodEventId, (jint)statuscode);
|
|
if (ret < 0)
|
|
g_vm->DetachCurrentThread();
|
|
LOG("JAVA--- Enter onEvent callback 10 \n");
|
|
}
|
|
else
|
|
LOG("JAVA--- mUserListener is null\n");
|
|
}
|
|
|
|
extern "C" JNIEXPORT jint JNICALL
|
|
JNI_OnLoad(JavaVM * vm, void* reserved)
|
|
{
|
|
JNIEnv* env;
|
|
if (g_vm == nullptr)
|
|
g_vm = vm;
|
|
|
|
if (g_vm->GetEnv((void**)&env, JNI_VERSION_1_6) != JNI_OK)
|
|
{
|
|
LOG("JAVA--- JNI_OnLoad error\n");
|
|
return JNI_ERR;
|
|
}
|
|
|
|
LOG("JAVA--- JNI_OnLoad\n");
|
|
return JNI_VERSION_1_6;
|
|
}
|
|
|
|
extern "C"
|
|
JNIEXPORT jobjectArray JNICALL
|
|
Java_com_huagao_scanner_DeviceManager_getDevices(JNIEnv * env, jobject thiz)
|
|
{
|
|
const char* sp = ";";
|
|
char* cDevices = HG_GetDevices(const_cast<char*>(sp));
|
|
if (cDevices == nullptr)
|
|
{
|
|
LOG(" JAVA--- getDevices is fail\n");
|
|
return NULL;
|
|
}
|
|
jstring devices = env->NewStringUTF(cDevices);
|
|
jclass strClazz = env->FindClass("java/lang/String");
|
|
jmethodID splitId = env->GetMethodID(strClazz, "split", "(Ljava/lang/String;)[Ljava/lang/String;");;
|
|
return static_cast<jobjectArray>(env->CallObjectMethod(devices, splitId, env->NewStringUTF(";")));
|
|
}
|
|
|
|
extern "C" JNIEXPORT void JNICALL
|
|
Java_com_huagao_scanner_DeviceManager_init(JNIEnv * env, jobject thiz)
|
|
{
|
|
HG_Init();
|
|
HG_Set_OnDeviceEvent_callback(onEvent);
|
|
HG_Set_AquireImg_callback(onReceivedImage);
|
|
LOG("JAVA--- DeviceManager_init\n");
|
|
}
|
|
|
|
extern "C"
|
|
JNIEXPORT void JNICALL
|
|
Java_com_huagao_scanner_DeviceManager_setEventListener(JNIEnv * env, jobject thiz, jobject listener)
|
|
{
|
|
if (mUserListener)
|
|
env->DeleteGlobalRef(mUserListener);
|
|
mUserListener = env->NewGlobalRef(listener);
|
|
}
|
|
|
|
extern "C"
|
|
JNIEXPORT jboolean JNICALL
|
|
Java_com_huagao_scanner_DeviceManager_open(JNIEnv * env, jobject thiz, jstring scanner_name)
|
|
{
|
|
if (mScanner)
|
|
return true;
|
|
|
|
char* cName = const_cast<char*>(env->GetStringUTFChars(scanner_name, 0));
|
|
LOG("JAVA--- open deivce name:%s \n", cName);
|
|
mScanner = HG_OpenScanner(cName);
|
|
env->ReleaseStringUTFChars(scanner_name, cName);
|
|
return mScanner != nullptr;
|
|
}
|
|
|
|
extern "C"
|
|
JNIEXPORT void JNICALL
|
|
Java_com_huagao_scanner_DeviceManager_close(JNIEnv * env, jobject thiz)
|
|
{
|
|
if (mScanner)
|
|
{
|
|
HG_CloseScanner(mScanner);
|
|
mScanner = nullptr;
|
|
}
|
|
}
|
|
|
|
extern "C"
|
|
JNIEXPORT jboolean JNICALL
|
|
Java_com_huagao_scanner_DeviceManager_setScanParam(JNIEnv * env, jobject thiz, jobject params)
|
|
{
|
|
if (mScanner)
|
|
{
|
|
HG_SCANPARAMS cParams;
|
|
jclass clazz = env->GetObjectClass(params);
|
|
//设置colorMode
|
|
jfieldID id = env->GetFieldID(clazz, "colorMode", "Lcom/huagao/scanner/enums/ColorMode;");
|
|
jobject fieldObj = env->GetObjectField(params, id);
|
|
jfieldID fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "value", "I");
|
|
cParams.PixelType = static_cast<HG_COLORMODE>(env->GetIntField(fieldObj, fieldId));
|
|
LOG("JAVA--- PixelType =%d \n", cParams.PixelType);
|
|
|
|
id = env->GetFieldID(clazz, "cacheImgFormat", "Lcom/huagao/scanner/enums/CacheImgFormat;");
|
|
fieldObj = env->GetObjectField(params, id);
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "value", "I");
|
|
m_cacheimgformat = static_cast<HG_CACHEIMGFORMAT>(env->GetIntField(fieldObj, fieldId));
|
|
|
|
id = env->GetFieldID(clazz, "multiOutput", "Lcom/huagao/scanner/enums/MultiOutput;");
|
|
fieldObj = env->GetObjectField(params, id);
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "multiMode", "I");
|
|
cParams.MultiOutput = static_cast<HG_MULTIOUTPUT>(env->GetIntField(fieldObj, fieldId) - 1);
|
|
LOG("JAVA--- MultiOutput =%d \n", cParams.MultiOutput);
|
|
|
|
id = env->GetFieldID(clazz, "paperType", "Lcom/huagao/scanner/enums/PaperType;");
|
|
fieldObj = env->GetObjectField(params, id);
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "value", "I");
|
|
cParams.PaperSize = static_cast<HG_PAPERTYPE>(env->GetIntField(fieldObj, fieldId));
|
|
LOG("JAVA--- PaperSize =%d \n", cParams.PaperSize);
|
|
|
|
id = env->GetFieldID(clazz, "paperAlign", "Lcom/huagao/scanner/enums/PaperAlign;");
|
|
fieldObj = env->GetObjectField(params, id);
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "value", "I");
|
|
cParams.PaperAlign = static_cast<HG_PAPERALIGN>(env->GetIntField(fieldObj, fieldId));
|
|
LOG("JAVA--- PaperAlign =%d \n", cParams.PaperAlign);
|
|
|
|
id = env->GetFieldID(clazz, "resolution", "I");
|
|
cParams.Resolution = env->GetIntField(params, id);
|
|
LOG("JAVA--- Resolution =%d \n", cParams.Resolution);
|
|
|
|
id = env->GetFieldID(clazz, "scanSide", "Lcom/huagao/scanner/params/ScanSide;");
|
|
fieldObj = env->GetObjectField(params, id);
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "switchFrontBack", "I");
|
|
cParams.ScanSide.SwitchFrontBack = env->GetIntField(fieldObj, fieldId);
|
|
LOG("JAVA--- SwitchFrontBack =%d \n", cParams.ScanSide.SwitchFrontBack);
|
|
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "discardBlank", "I");
|
|
cParams.ScanSide.DiscardBlank = env->GetIntField(fieldObj, fieldId);
|
|
LOG("JAVA--- DiscardBlank =%d \n", cParams.ScanSide.DiscardBlank);
|
|
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "discardBlankVince", "I");
|
|
cParams.ScanSide.DiscardBlankVince = env->GetIntField(fieldObj, fieldId);
|
|
LOG("JAVA--- DiscardBlankVince =%d \n", cParams.ScanSide.DiscardBlankVince);
|
|
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "duplex", "I");
|
|
cParams.ScanSide.Duplex = env->GetIntField(fieldObj, fieldId);
|
|
LOG("JAVA--- Duplex =%d \n", cParams.ScanSide.Duplex);
|
|
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "fold", "I");
|
|
cParams.ScanSide.Fold = env->GetIntField(fieldObj, fieldId);
|
|
LOG("JAVA--- Fold =%d \n", cParams.ScanSide.Fold);
|
|
|
|
id = env->GetFieldID(clazz, "imageProcessParams", "Lcom/huagao/scanner/params/ImageProcessParams;");
|
|
fieldObj = env->GetObjectField(params, id);
|
|
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "discardBlankThre", "I");
|
|
cParams.ImageProcess.DiscardBlankThre = env->GetIntField(fieldObj, fieldId);
|
|
LOG("JAVA--- AnswerSheetFilterRed =%d \n", cParams.ImageProcess.DiscardBlankThre);
|
|
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "autoCrop", "I");
|
|
cParams.ImageProcess.AutoCrop = env->GetIntField(fieldObj, fieldId);
|
|
LOG("JAVA--- AutoCrop =%d \n", cParams.ImageProcess.AutoCrop);
|
|
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "autoCrop", "I");
|
|
cParams.ImageProcess.AutoCrop = env->GetIntField(fieldObj, fieldId);
|
|
LOG("JAVA--- AutoCrop =%d \n", cParams.ImageProcess.AutoCrop);
|
|
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "autoCropThreshold", "I");
|
|
cParams.ImageProcess.AutoCrop_threshold = env->GetIntField(fieldObj, fieldId);
|
|
LOG("JAVA--- AutoCrop_threshold =%d \n", cParams.ImageProcess.AutoCrop_threshold);
|
|
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "autoDescrew", "I");
|
|
cParams.ImageProcess.AutoDescrew = env->GetIntField(fieldObj, fieldId);
|
|
LOG("JAVA--- AutoDescrew =%d \n", cParams.ImageProcess.AutoDescrew);
|
|
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "backRotate180", "I");
|
|
cParams.ImageProcess.BackRotate180 = env->GetIntField(fieldObj, fieldId);
|
|
LOG("JAVA--- BackRotate180 =%d \n", cParams.ImageProcess.BackRotate180);
|
|
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "colorCorrection", "I");
|
|
cParams.ImageProcess.ColorCorrection = env->GetIntField(fieldObj, fieldId);
|
|
LOG("JAVA--- ColorCorrection =%d \n", cParams.ImageProcess.ColorCorrection);
|
|
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "contrast", "I");
|
|
cParams.ImageProcess.Contrast = env->GetIntField(fieldObj, fieldId);
|
|
LOG("JAVA--- Contrast =%d \n", cParams.ImageProcess.Contrast);
|
|
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "brightness", "I");
|
|
cParams.ImageProcess.Brightness = env->GetIntField(fieldObj, fieldId);
|
|
LOG("JAVA--- Brightness =%d \n", cParams.ImageProcess.Brightness);
|
|
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "errorExtention", "I");
|
|
cParams.ImageProcess.ErrorExtention = env->GetIntField(fieldObj, fieldId);
|
|
LOG("JAVA--- ErrorExtention =%d \n", cParams.ImageProcess.ErrorExtention);
|
|
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "fillBlackRect", "I");
|
|
cParams.ImageProcess.FillBlackRect = env->GetIntField(fieldObj, fieldId);
|
|
LOG("JAVA--- FillBlackRect =%d \n", cParams.ImageProcess.FillBlackRect);
|
|
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "fillHole", "Lcom/huagao/scanner/params/FillHole;");
|
|
jobject fFieldObj = env->GetObjectField(fieldObj, fieldId);
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fFieldObj), "enbaleFileHole", "I");
|
|
cParams.ImageProcess.FillHole.enable = env->GetIntField(fFieldObj, fieldId);
|
|
LOG("JAVA--- FillHole.enable =%d \n", cParams.ImageProcess.FillHole.enable);
|
|
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fFieldObj), "SearchRatio", "I");
|
|
cParams.ImageProcess.FillHole.ratio = env->GetIntField(fFieldObj, fieldId);
|
|
LOG("JAVA--- FillHole.ratio =%d \n", cParams.ImageProcess.FillHole.ratio);
|
|
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "filter", "Lcom/huagao/scanner/enums/Filter;");
|
|
fFieldObj = env->GetObjectField(fieldObj, fieldId);
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fFieldObj), "value", "I");
|
|
cParams.ImageProcess.Filter = static_cast<HG_FILTER>(env->GetIntField(fFieldObj, fieldId));
|
|
LOG("JAVA--- Filter =%d \n", cParams.ImageProcess.Filter);
|
|
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "gamma", "F");
|
|
cParams.ImageProcess.Gamma = env->GetFloatField(fieldObj, fieldId);
|
|
LOG("JAVA--- Gamma =%.2f \n", cParams.ImageProcess.Gamma);
|
|
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "indent", "I");
|
|
cParams.ImageProcess.Indent = env->GetIntField(fieldObj, fieldId);
|
|
LOG("JAVA--- Indent =%d \n", cParams.ImageProcess.Indent);
|
|
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "IsConvex", "Z");
|
|
cParams.ImageProcess.Is_convex = env->GetBooleanField(fieldObj, fieldId);
|
|
LOG("JAVA--- Is_convex =%d \n", cParams.ImageProcess.Is_convex);
|
|
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "multiOutFilterRed", "I");
|
|
cParams.ImageProcess.MultiOutFilterRed = env->GetIntField(fieldObj, fieldId);
|
|
LOG("JAVA--- MultiOutFilterRed =%d \n", cParams.ImageProcess.MultiOutFilterRed);
|
|
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "noise", "I");
|
|
cParams.ImageProcess.Noise = env->GetIntField(fieldObj, fieldId);
|
|
LOG("JAVA--- Noise =%d \n", cParams.ImageProcess.Noise);
|
|
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "noiseDetach", "I");
|
|
cParams.ImageProcess.NosieDetach = env->GetIntField(fieldObj, fieldId);
|
|
LOG("JAVA--- NosieDetach =%d \n", cParams.ImageProcess.NosieDetach);
|
|
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "orentation", "Lcom/huagao/scanner/enums/Orentation;");
|
|
fFieldObj = env->GetObjectField(fieldObj, fieldId);
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fFieldObj), "value", "I");
|
|
cParams.ImageProcess.Orentation = static_cast<HG_ORENTATION>(env->GetIntField(fFieldObj, fieldId));
|
|
LOG("JAVA--- Orentation =%d \n", cParams.ImageProcess.Orentation);
|
|
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "refuseInflow", "I");
|
|
cParams.ImageProcess.RefuseInflow = env->GetIntField(fieldObj, fieldId);
|
|
LOG("JAVA--- RefuseInflow =%d \n", cParams.ImageProcess.RefuseInflow);
|
|
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "removeMorre", "I");
|
|
cParams.ImageProcess.RemoveMorr = env->GetIntField(fieldObj, fieldId);
|
|
LOG("JAVA--- RemoveMorr =%d \n", cParams.ImageProcess.RemoveMorr);
|
|
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "sharpenType", "Lcom/huagao/scanner/enums/SharpenType;");
|
|
fFieldObj = env->GetObjectField(fieldObj, fieldId);
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fFieldObj), "value", "I");
|
|
cParams.ImageProcess.SharpenType = (HG_SHARPENTYPE)env->GetIntField(fFieldObj, fieldId);
|
|
LOG("JAVA--- SharpenType =%d \n", cParams.ImageProcess.SharpenType);
|
|
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "splitImage", "I");
|
|
cParams.ImageProcess.SplitImage = env->GetIntField(fieldObj, fieldId);
|
|
LOG("JAVA--- SplitImage =%d \n", cParams.ImageProcess.SplitImage);
|
|
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "textureRemove", "I");
|
|
cParams.ImageProcess.TextureRemove = env->GetIntField(fieldObj, fieldId);
|
|
LOG("JAVA--- TextureRemove =%d \n", cParams.ImageProcess.TextureRemove);
|
|
|
|
id = env->GetFieldID(clazz, "hardwareCaps", "Lcom/huagao/scanner/params/HardwareCaps;");
|
|
fieldObj = env->GetObjectField(params, id);
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "bindingDetect", "I");
|
|
cParams.HardwareParam.bindingDetection = static_cast<HG_PAPERALIGN>(env->GetIntField(fieldObj, fieldId));
|
|
LOG("JAVA--- bindingDetection =%d \n", cParams.HardwareParam.bindingDetection);
|
|
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "capturePixType", "I");
|
|
cParams.HardwareParam.capturepixtype = static_cast<HG_PAPERALIGN>(env->GetIntField(fieldObj, fieldId));
|
|
LOG("JAVA--- capturepixtype =%d \n", cParams.HardwareParam.capturepixtype);
|
|
|
|
fieldId = env->GetFieldID(env->GetObjectClass(fieldObj), "doubleFeedDetection", "I");
|
|
cParams.HardwareParam.doubleFeedDetection = static_cast<HG_PAPERALIGN>(env->GetIntField(fieldObj, fieldId));
|
|
LOG("JAVA--- doubleFeedDetection =%d \n", cParams.HardwareParam.doubleFeedDetection);
|
|
|
|
return HG_Set_Scan_Params(mScanner, cParams);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
extern "C"
|
|
JNIEXPORT jobject JNICALL
|
|
Java_com_huagao_scanner_DeviceManager_getScanParam(JNIEnv * env, jobject thiz)
|
|
{
|
|
HG_SCANPARAMS cparams;
|
|
if (mScanner)
|
|
{
|
|
HG_Get_Scan_Params(mScanner, &cparams);
|
|
jclass myclass = env->FindClass("com/huagao/scanner/ScanParam");
|
|
jmethodID id = env->GetMethodID(myclass, "<init>", "()V");
|
|
jobject jvScanparam = env->NewObject(myclass, id);//调用构造函数
|
|
|
|
return jvScanparam;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
extern "C"
|
|
JNIEXPORT jint JNICALL
|
|
Java_com_huagao_scanner_DeviceManager_startScan(JNIEnv * env, jobject thiz, jint count)
|
|
{
|
|
LOG("JAVA--- strat scan\n");
|
|
return HG_StartScan(mScanner, count);
|
|
}
|
|
|
|
extern "C"
|
|
JNIEXPORT jint JNICALL
|
|
Java_com_huagao_scanner_DeviceManager_stopScan(JNIEnv * env, jobject thiz)
|
|
{
|
|
return HG_StopScan(mScanner);
|
|
}
|
|
|
|
extern "C"
|
|
JNIEXPORT jboolean JNICALL
|
|
Java_com_huagao_scanner_DeviceManager_isRunning(JNIEnv * env, jobject thiz)
|
|
{
|
|
if (mScanner)
|
|
return HG_Is_Running(mScanner) != 0;
|
|
return 0;
|
|
}
|
|
|
|
extern "C"
|
|
JNIEXPORT jboolean JNICALL
|
|
Java_com_huagao_scanner_DeviceManager_isPaperPutted(JNIEnv * env, jobject thiz)
|
|
{
|
|
if (mScanner)
|
|
return HG_Is_FeederLoaded(mScanner) != 0;
|
|
return 0;
|
|
}
|
|
|
|
extern "C"
|
|
JNIEXPORT void JNICALL
|
|
Java_com_huagao_scanner_DeviceManager_setImageCallback(JNIEnv * env, jobject thiz, jobject callback)
|
|
{
|
|
if (mUserCallback)
|
|
env->DeleteGlobalRef(mUserCallback);
|
|
mUserCallback = env->NewGlobalRef(callback);
|
|
}
|
|
|
|
extern "C"
|
|
JNIEXPORT jint JNICALL
|
|
Java_com_huagao_scanner_DeviceManager_createMultiDocs(JNIEnv * env, jobject thiz, jobjectArray src_files, jstring dest_path)
|
|
{
|
|
//const int len = env->GetArrayLength(src_files);
|
|
//char** cSrcPaths = new char*[len];
|
|
|
|
//for (int i = 0; i < len; i++) {
|
|
// jstring jPath = (jstring)env->GetObjectArrayElement(src_files, i);
|
|
// cSrcPaths[i] = (char*)const_cast<jchar*>(env->GetStringChars(jPath, 0));
|
|
//}
|
|
//char *cDestPath = const_cast<char*>(env->GetStringUTFChars(dest_path, 0));
|
|
//jint ret = HG_Create_MultiPageDocument(cSrcPaths, len, cDestPath);
|
|
//env->ReleaseStringUTFChars(dest_path, cDestPath);
|
|
//for (int i = 0; i < len; i++) {
|
|
// jstring jPath = (jstring)env->GetObjectArrayElement(src_files, i);
|
|
// env->ReleaseStringUTFChars(jPath, cSrcPaths[i]);
|
|
//}
|
|
|
|
//delete[] cSrcPaths;
|
|
jint ret = 0;
|
|
return ret;
|
|
}
|
|
|
|
extern "C"
|
|
JNIEXPORT jint JNICALL
|
|
Java_com_huagao_scanner_DeviceManager_createMultiTiffs(JNIEnv * env, jobject thiz, jobjectArray src_files, jstring dest_path)
|
|
{
|
|
const int len = env->GetArrayLength(src_files);
|
|
char** cSrcPaths = new char* [len];
|
|
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
jstring jPath = (jstring)env->GetObjectArrayElement(src_files, i);
|
|
jsize strlen = env->GetStringUTFLength(jPath);
|
|
{
|
|
cSrcPaths[i] = new char[strlen];
|
|
cSrcPaths[i] = const_cast<char*>(env->GetStringUTFChars(jPath, nullptr));
|
|
}
|
|
}
|
|
|
|
char* cDestPath = const_cast<char*>(env->GetStringUTFChars(dest_path, 0));
|
|
jint ret = HG_Create_MultiTiff(cSrcPaths, len, cDestPath);
|
|
env->ReleaseStringUTFChars(dest_path, cDestPath);
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
jstring jPath = (jstring)env->GetObjectArrayElement(src_files, i);
|
|
env->ReleaseStringUTFChars(jPath, cSrcPaths[i]);
|
|
}
|
|
delete[] cSrcPaths;
|
|
return ret;
|
|
}
|
|
extern "C"
|
|
JNIEXPORT jstring JNICALL
|
|
Java_com_huagao_scanner_DeviceManager_getSDKVersion(JNIEnv * env, jobject thiz)
|
|
{
|
|
char* cVersion = HG_GetSDKVersion();
|
|
LOG("JAVA--- get SDKVersion:%s\n", cVersion);
|
|
if (cVersion == nullptr)
|
|
return NULL;
|
|
|
|
jstring strver = env->NewStringUTF(cVersion);
|
|
return strver;
|
|
}
|
|
|
|
extern "C"
|
|
JNIEXPORT jstring JNICALL
|
|
Java_com_huagao_scanner_DeviceManager_getFwVersion(JNIEnv * env, jobject thiz)
|
|
{
|
|
const char* cVersion = HG_GetFwVersion(mScanner);
|
|
LOG("JAVA--- get version:%s\n", cVersion);
|
|
if (cVersion == nullptr)
|
|
return NULL;
|
|
jstring strver = env->NewStringUTF(cVersion);
|
|
return strver;
|
|
}
|
|
|
|
extern "C"
|
|
JNIEXPORT jstring JNICALL
|
|
Java_com_huagao_scanner_DeviceManager_getSerialNum(JNIEnv * env, jobject thiz)
|
|
{
|
|
const char* cVersion = HG_GetSerialNum(mScanner);
|
|
LOG("JAVA--- getSerialNum =%s \n", cVersion);
|
|
if (cVersion == nullptr)
|
|
return NULL;
|
|
|
|
jstring strver = env->NewStringUTF(cVersion);
|
|
return strver;
|
|
}
|
|
|
|
|
|
extern "C"
|
|
JNIEXPORT void JNICALL
|
|
Java_com_huagao_scanner_DeviceManager_resetPatchIndex(JNIEnv * env, jobject thiz)
|
|
{
|
|
indexPatch = 0;
|
|
LOG("JAVA--- clean indexPatch:%d\n", indexPatch);
|
|
}
|