void Java_com_googlecode_tesseract_android_TessBaseAPI_nativeSetImagePix(JNIEnv *env,
jobject thiz,
jlong nativePix) {
PIX *pixs = (PIX *) nativePix;
PIX *pixd = pixClone(pixs);
native_data_t *nat = get_native_data(env, thiz);
if (pixd) {
l_int32 width = pixGetWidth(pixd);
l_int32 height = pixGetHeight(pixd);
nat->setTextBoundaries(0, 0, width, height);
}
nat->api.SetImage(pixd);
// Since Tesseract doesn't take ownership of the memory, we keep a pointer in the native
// code struct. We need to free that pointer when we release our instance of Tesseract or
// attempt to set a new image using one of the nativeSet* methods.
if (nat->data != NULL)
free(nat->data);
else if (nat->pix != NULL)
pixDestroy(&nat->pix);
nat->data = NULL;
nat->pix = pixd;
}
static jint addRfcommServiceRecordNative(JNIEnv *env, jobject object,
jstring name, jlong uuidMsb, jlong uuidLsb, jshort channel) {
LOGV(__FUNCTION__);
#ifdef HAVE_BLUETOOTH
native_data_t *nat = get_native_data(env, object);
if (nat) {
const char *c_name = env->GetStringUTFChars(name, NULL);
LOGV("... name = %s", c_name);
LOGV("... uuid1 = %llX", uuidMsb);
LOGV("... uuid2 = %llX", uuidLsb);
LOGV("... channel = %d", channel);
DBusMessage *reply = dbus_func_args(env, nat->conn,
get_adapter_path(env, object),
DBUS_ADAPTER_IFACE, "AddRfcommServiceRecord",
DBUS_TYPE_STRING, &c_name,
DBUS_TYPE_UINT64, &uuidMsb,
DBUS_TYPE_UINT64, &uuidLsb,
DBUS_TYPE_UINT16, &channel,
DBUS_TYPE_INVALID);
env->ReleaseStringUTFChars(name, c_name);
return reply ? dbus_returns_uint32(env, reply) : -1;
}
#endif
return -1;
}
static jboolean createPairedDeviceOutOfBandNative(JNIEnv *env, jobject object,
jstring address, jint timeout_ms) {
LOGV(__FUNCTION__);
#ifdef HAVE_BLUETOOTH
native_data_t *nat = get_native_data(env, object);
jobject eventLoop = env->GetObjectField(object, field_mEventLoop);
struct event_loop_native_data_t *eventLoopNat =
get_EventLoop_native_data(env, eventLoop);
if (nat && eventLoopNat) {
const char *c_address = env->GetStringUTFChars(address, NULL);
LOGV("... address = %s", c_address);
char *context_address = (char *)calloc(BTADDR_SIZE, sizeof(char));
const char *capabilities = "DisplayYesNo";
const char *agent_path = "/android/bluetooth/remote_device_agent";
strlcpy(context_address, c_address, BTADDR_SIZE); // for callback
bool ret = dbus_func_args_async(env, nat->conn, (int)timeout_ms,
onCreatePairedDeviceResult, // callback
context_address,
eventLoopNat,
get_adapter_path(env, object),
DBUS_ADAPTER_IFACE,
"CreatePairedDeviceOutOfBand",
DBUS_TYPE_STRING, &c_address,
DBUS_TYPE_OBJECT_PATH, &agent_path,
DBUS_TYPE_STRING, &capabilities,
DBUS_TYPE_INVALID);
env->ReleaseStringUTFChars(address, c_address);
return ret ? JNI_TRUE : JNI_FALSE;
}
#endif
return JNI_FALSE;
}
static jboolean createDeviceNative(JNIEnv *env, jobject object,
jstring address) {
LOGV(__FUNCTION__);
#ifdef HAVE_BLUETOOTH
native_data_t *nat = get_native_data(env, object);
jobject eventLoop = env->GetObjectField(object, field_mEventLoop);
struct event_loop_native_data_t *eventLoopNat =
get_EventLoop_native_data(env, eventLoop);
if (nat && eventLoopNat) {
const char *c_address = env->GetStringUTFChars(address, NULL);
LOGV("... address = %s", c_address);
char *context_address = (char *)calloc(BTADDR_SIZE, sizeof(char));
strlcpy(context_address, c_address, BTADDR_SIZE); // for callback
bool ret = dbus_func_args_async(env, nat->conn, -1,
onCreateDeviceResult,
context_address,
eventLoopNat,
get_adapter_path(env, object),
DBUS_ADAPTER_IFACE,
"CreateDevice",
DBUS_TYPE_STRING, &c_address,
DBUS_TYPE_INVALID);
env->ReleaseStringUTFChars(address, c_address);
return ret ? JNI_TRUE : JNI_FALSE;
}
#endif
return JNI_FALSE;
}
static jboolean discoverServicesNative(JNIEnv *env, jobject object,
jstring path, jstring pattern) {
LOGV(__FUNCTION__);
#ifdef HAVE_BLUETOOTH
native_data_t *nat = get_native_data(env, object);
jobject eventLoop = env->GetObjectField(object, field_mEventLoop);
struct event_loop_native_data_t *eventLoopNat =
get_EventLoop_native_data(env, eventLoop);
if (nat && eventLoopNat) {
const char *c_path = env->GetStringUTFChars(path, NULL);
const char *c_pattern = env->GetStringUTFChars(pattern, NULL);
int len = env->GetStringLength(path) + 1;
char *context_path = (char *)calloc(len, sizeof(char));
strlcpy(context_path, c_path, len); // for callback
LOGV("... Object Path = %s", c_path);
LOGV("... Pattern = %s, strlen = %d", c_pattern, strlen(c_pattern));
bool ret = dbus_func_args_async(env, nat->conn, -1,
onDiscoverServicesResult,
context_path,
eventLoopNat,
c_path,
DBUS_DEVICE_IFACE,
"DiscoverServices",
DBUS_TYPE_STRING, &c_pattern,
DBUS_TYPE_INVALID);
env->ReleaseStringUTFChars(path, c_path);
env->ReleaseStringUTFChars(pattern, c_pattern);
return ret ? JNI_TRUE : JNI_FALSE;
}
#endif
return JNI_FALSE;
}
static jboolean setPasskeyNative(JNIEnv *env, jobject object, jstring address,
int passkey, int nativeData) {
#ifdef HAVE_BLUETOOTH
LOGV(__FUNCTION__);
native_data_t *nat = get_native_data(env, object);
if (nat) {
DBusMessage *msg = (DBusMessage *)nativeData;
DBusMessage *reply = dbus_message_new_method_return(msg);
if (!reply) {
LOGE("%s: Cannot create message reply to return Passkey code to "
"D-Bus\n", __FUNCTION__);
dbus_message_unref(msg);
return JNI_FALSE;
}
dbus_message_append_args(reply, DBUS_TYPE_UINT32, (uint32_t *)&passkey,
DBUS_TYPE_INVALID);
dbus_connection_send(nat->conn, reply, NULL);
dbus_message_unref(msg);
dbus_message_unref(reply);
return JNI_TRUE;
}
#endif
return JNI_FALSE;
}
static jboolean setPinNative(JNIEnv *env, jobject object, jstring address,
jstring pin, int nativeData) {
#ifdef HAVE_BLUETOOTH
LOGV(__FUNCTION__);
native_data_t *nat = get_native_data(env, object);
if (nat) {
DBusMessage *msg = (DBusMessage *)nativeData;
DBusMessage *reply = dbus_message_new_method_return(msg);
if (!reply) {
LOGE("%s: Cannot create message reply to return PIN code to "
"D-Bus\n", __FUNCTION__);
dbus_message_unref(msg);
return JNI_FALSE;
}
const char *c_pin = env->GetStringUTFChars(pin, NULL);
dbus_message_append_args(reply, DBUS_TYPE_STRING, &c_pin,
DBUS_TYPE_INVALID);
dbus_connection_send(nat->conn, reply, NULL);
dbus_message_unref(msg);
dbus_message_unref(reply);
env->ReleaseStringUTFChars(pin, c_pin);
return JNI_TRUE;
}
#endif
return JNI_FALSE;
}
jintArray Java_com_googlecode_tesseract_android_TessBaseAPI_nativeWordConfidences(JNIEnv *env,
jobject thiz) {
// LOGV(__FUNCTION__);
native_data_t *nat = get_native_data(env, thiz);
int *confs = nat->api.AllWordConfidences();
if (confs == NULL) {
LOGE("Could not get word-confidence values!");
return NULL;
}
int len, *trav;
for (len = 0, trav = confs; *trav != -1; trav++, len++)
;
LOG_ASSERT((confs != NULL), "Confidence array has %d elements", len);
jintArray ret = env->NewIntArray(len);
LOG_ASSERT((ret != NULL), "Could not create Java confidence array!");
env->SetIntArrayRegion(ret, 0, len, confs);
delete[] confs;
return ret;
}
jint Java_com_googlecode_tesseract_android_TessBaseAPI_nativeGetCharacters(JNIEnv *env,
jobject thiz) {
// LOGV(__FUNCTION__);
native_data_t *nat = get_native_data(env, thiz);
return reinterpret_cast<jint>(nat->api.GetCharacters());
}
void Java_com_googlecode_tesseract_android_TessBaseAPI_nativeSetImageBytes(JNIEnv *env,
jobject thiz,
jbyteArray data,
jint width,
jint height, jint bpp,
jint bpl) {
// LOGV(__FUNCTION__);
jbyte *data_array = env->GetByteArrayElements(data, NULL);
int count = env->GetArrayLength(data);
unsigned char* imagedata = (unsigned char *) malloc(count * sizeof(unsigned char));
// This is painfully slow, but necessary because we don't know
// how many bits the JVM might be using to represent a byte
for (int i = 0; i < count; i++) {
imagedata[i] = (unsigned char) data_array[i];
}
env->ReleaseByteArrayElements(data, data_array, JNI_ABORT);
native_data_t *nat = get_native_data(env, thiz);
nat->api.SetImage(imagedata, (int) width, (int) height, (int) bpp, (int) bpl);
// Since Tesseract doesn't take ownership of the memory, we keep a pointer in the native
// code struct. We need to free that pointer when we release our instance of Tesseract or
// attempt to set a new image using one of the nativeSet* methods.
if (nat->data != NULL)
free(nat->data);
else if (nat->pix != NULL)
pixDestroy(&nat->pix);
nat->data = imagedata;
nat->pix = NULL;
}
void Java_com_googlecode_tesseract_android_TessBaseAPI_nativeStop(JNIEnv *env, jobject thiz) {
// LOGV(__FUNCTION__);
native_data_t *nat = get_native_data(env, thiz);
// TODO How do we stop without a monitor?!
}
jint Java_com_googlecode_tesseract_android_TessBaseAPI_nativeMeanConfidence(JNIEnv *env,
jobject thiz) {
native_data_t *nat = get_native_data(env, thiz);
return (jint) nat->api.MeanTextConf();
}
jboolean Java_com_googlecode_tesseract_android_TessBaseAPI_nativeInitOem(JNIEnv *env,
jobject thiz,
jstring dir,
jstring lang,
jint mode) {
native_data_t *nat = get_native_data(env, thiz);
const char *c_dir = env->GetStringUTFChars(dir, NULL);
const char *c_lang = env->GetStringUTFChars(lang, NULL);
jboolean res = JNI_TRUE;
if (nat->api.Init(c_dir, c_lang, (tesseract::OcrEngineMode) mode)) {
LOGE("Could not initialize Tesseract API with language=%s!", c_lang);
res = JNI_FALSE;
} else {
LOGI("Initialized Tesseract API with language=%s", c_lang);
}
env->ReleaseStringUTFChars(dir, c_dir);
env->ReleaseStringUTFChars(lang, c_lang);
return res;
}
jint Java_com_googlecode_tesseract_android_TessBaseAPI_nativeGetPageSegMode(JNIEnv *env,
jobject thiz) {
native_data_t *nat = get_native_data(env, thiz);
return nat->api.GetPageSegMode();
}
static jboolean cancelDeviceCreationNative(JNIEnv *env, jobject object,
jstring address) {
LOGV(__FUNCTION__);
jboolean result = JNI_FALSE;
#ifdef HAVE_BLUETOOTH
native_data_t *nat = get_native_data(env, object);
if (nat) {
const char *c_address = env->GetStringUTFChars(address, NULL);
DBusError err;
dbus_error_init(&err);
LOGV("... address = %s", c_address);
DBusMessage *reply =
dbus_func_args_timeout(env, nat->conn, -1,
get_adapter_path(env, object),
DBUS_ADAPTER_IFACE, "CancelDeviceCreation",
DBUS_TYPE_STRING, &c_address,
DBUS_TYPE_INVALID);
env->ReleaseStringUTFChars(address, c_address);
if (!reply) {
if (dbus_error_is_set(&err)) {
LOG_AND_FREE_DBUS_ERROR(&err);
} else
LOGE("DBus reply is NULL in function %s", __FUNCTION__);
return JNI_FALSE;
} else {
result = JNI_TRUE;
}
dbus_message_unref(reply);
}
#endif
return JNI_FALSE;
}
jboolean Java_com_googlecode_tesseract_android_TessBaseAPI_nativeInit(JNIEnv *env, jobject thiz,
jstring dir, jstring lang) {
// LOGV(__FUNCTION__);
native_data_t *nat = get_native_data(env, thiz);
const char *c_dir = env->GetStringUTFChars(dir, NULL);
const char *c_lang = env->GetStringUTFChars(lang, NULL);
LOGI("Attempting Init() with dir=%s, lang=%s", c_dir, c_lang);
jboolean res = JNI_TRUE;
if (nat->api.Init(c_dir, c_lang)) {
LOGE("Could not initialize Tesseract API with language=%s!", c_lang);
res = JNI_FALSE;
} else {
LOGI("Initialized Tesseract API with language=%s", c_lang);
}
env->ReleaseStringUTFChars(lang, c_dir);
env->ReleaseStringUTFChars(lang, c_lang);
return res;
}
static jboolean setPairingConfirmationNative(JNIEnv *env, jobject object,
jstring address, bool confirm,
int nativeData) {
#ifdef HAVE_BLUETOOTH
LOGV(__FUNCTION__);
native_data_t *nat = get_native_data(env, object);
if (nat) {
DBusMessage *msg = (DBusMessage *)nativeData;
DBusMessage *reply;
if (confirm) {
reply = dbus_message_new_method_return(msg);
} else {
reply = dbus_message_new_error(msg,
"org.bluez.Error.Rejected", "User rejected confirmation");
}
if (!reply) {
LOGE("%s: Cannot create message reply to RequestPasskeyConfirmation or"
"RequestPairingConsent to D-Bus\n", __FUNCTION__);
dbus_message_unref(msg);
return JNI_FALSE;
}
dbus_connection_send(nat->conn, reply, NULL);
dbus_message_unref(msg);
dbus_message_unref(reply);
return JNI_TRUE;
}
#endif
return JNI_FALSE;
}
static jobjectArray getAdapterPropertiesNative(JNIEnv *env, jobject object) {
#ifdef HAVE_BLUETOOTH
LOGV(__FUNCTION__);
native_data_t *nat = get_native_data(env, object);
if (nat) {
DBusMessage *msg, *reply;
DBusError err;
dbus_error_init(&err);
reply = dbus_func_args_timeout(env,
nat->conn, -1, get_adapter_path(env, object),
DBUS_ADAPTER_IFACE, "GetProperties",
DBUS_TYPE_INVALID);
if (!reply) {
if (dbus_error_is_set(&err)) {
LOG_AND_FREE_DBUS_ERROR(&err);
} else
LOGE("DBus reply is NULL in function %s", __FUNCTION__);
return NULL;
}
env->PushLocalFrame(PROPERTIES_NREFS);
DBusMessageIter iter;
jobjectArray str_array = NULL;
if (dbus_message_iter_init(reply, &iter))
str_array = parse_adapter_properties(env, &iter);
dbus_message_unref(reply);
env->PopLocalFrame(NULL);
return str_array;
}
#endif
return NULL;
}
static jboolean setRemoteOutOfBandDataNative(JNIEnv *env, jobject object, jstring address,
jbyteArray hash, jbyteArray randomizer, int nativeData) {
#ifdef HAVE_BLUETOOTH
LOGV(__FUNCTION__);
native_data_t *nat = get_native_data(env, object);
if (nat) {
DBusMessage *msg = (DBusMessage *)nativeData;
DBusMessage *reply = dbus_message_new_method_return(msg);
jbyte *h_ptr = env->GetByteArrayElements(hash, NULL);
jbyte *r_ptr = env->GetByteArrayElements(randomizer, NULL);
if (!reply) {
LOGE("%s: Cannot create message reply to return remote OOB data to "
"D-Bus\n", __FUNCTION__);
dbus_message_unref(msg);
return JNI_FALSE;
}
dbus_message_append_args(reply,
DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &h_ptr, 16,
DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &r_ptr, 16,
DBUS_TYPE_INVALID);
env->ReleaseByteArrayElements(hash, h_ptr, 0);
env->ReleaseByteArrayElements(randomizer, r_ptr, 0);
dbus_connection_send(nat->conn, reply, NULL);
dbus_message_unref(msg);
dbus_message_unref(reply);
return JNI_TRUE;
}
#endif
return JNI_FALSE;
}
static jint getDeviceServiceChannelNative(JNIEnv *env, jobject object,
jstring path,
jstring pattern, jint attr_id) {
#ifdef HAVE_BLUETOOTH
LOGV(__FUNCTION__);
native_data_t *nat = get_native_data(env, object);
jobject eventLoop = env->GetObjectField(object, field_mEventLoop);
struct event_loop_native_data_t *eventLoopNat =
get_EventLoop_native_data(env, eventLoop);
if (nat && eventLoopNat) {
const char *c_pattern = env->GetStringUTFChars(pattern, NULL);
const char *c_path = env->GetStringUTFChars(path, NULL);
LOGV("... pattern = %s", c_pattern);
LOGV("... attr_id = %#X", attr_id);
DBusMessage *reply =
dbus_func_args(env, nat->conn, c_path,
DBUS_DEVICE_IFACE, "GetServiceAttributeValue",
DBUS_TYPE_STRING, &c_pattern,
DBUS_TYPE_UINT16, &attr_id,
DBUS_TYPE_INVALID);
env->ReleaseStringUTFChars(pattern, c_pattern);
env->ReleaseStringUTFChars(path, c_path);
return reply ? dbus_returns_int32(env, reply) : -1;
}
#endif
return -1;
}
static void wakeupListenerNative(JNIEnv* env, jobject object)
{
HID_LOG("wakeupListenerNative");
native_data_t *nat = get_native_data(env, object);
int event=1;
if(nat)
{
sockaddr_un name;
socklen_t namelen;
int ret;
namelen = sizeof(sockaddr_un);
ret = getsockname(nat->servsock, (struct sockaddr*)&name, &namelen);
HID_LOG("nat->hfgservsock : name=%s, size=%d", &name.sun_path[1], namelen);
if(ret == 0 && namelen > 0)
{
//ret = sendto(nat->servsock, &event, sizeof(int), 0, (struct sockaddr*)&name, namelen);
ret = sendto(nat->servsock, 0, 0, 0, (struct sockaddr*)&name, namelen);
if(ret < 0)
{
HID_ERR("[ERR] sendto servsock itself failed : %s, errno=%d", strerror(errno), errno);
}
}
else
{
HID_ERR("[ERR] getsockname failed : %s, errno=%d", strerror(errno), errno);
}
}
else
{
HID_ERR("[ERR] nat is null");
}
}
void Java_com_googlecode_tesseract_android_TessBaseAPI_nativeSetOutputName(JNIEnv *env,
jobject thiz,
jstring name) {
native_data_t *nat = get_native_data(env, thiz);
const char *c_name = env->GetStringUTFChars(name, NULL);
nat->api.SetOutputName(c_name);
env->ReleaseStringUTFChars(name, c_name);
}
void Java_com_googlecode_tesseract_android_TessBaseAPI_nativeReadConfigFile(JNIEnv *env,
jobject thiz,
jstring fileName) {
native_data_t *nat = get_native_data(env, thiz);
const char *c_file_name = env->GetStringUTFChars(fileName, NULL);
nat->api.ReadConfigFile(c_file_name);
env->ReleaseStringUTFChars(fileName, c_file_name);
}
void Java_com_googlecode_tesseract_android_TessBaseAPI_nativeSetPageSegMode(JNIEnv *env,
jobject thiz,
jint mode) {
native_data_t *nat = get_native_data(env, thiz);
nat->api.SetPageSegMode((tesseract::PageSegMode) mode);
}
void Java_com_googlecode_tesseract_android_TessBaseAPI_nativeSetDebug(JNIEnv *env,
jobject thiz,
jboolean debug) {
native_data_t *nat = get_native_data(env, thiz);
nat->debug = (debug == JNI_TRUE) ? TRUE : FALSE;
}
jstring Java_com_googlecode_tesseract_android_TessBaseAPI_nativeGetVersion(JNIEnv *env,
jobject thiz) {
native_data_t *nat = get_native_data(env, thiz);
const char *text = nat->api.Version();
jstring result = env->NewStringUTF(text);
return result;
}
jlong Java_com_googlecode_tesseract_android_TessBaseAPI_nativeGetThresholdedImage(JNIEnv *env,
jobject thiz) {
native_data_t *nat = get_native_data(env, thiz);
PIX *pix = nat->api.GetThresholdedImage();
return (jlong) pix;
}
void Java_com_googlecode_tesseract_android_TessBaseAPI_nativeStop(JNIEnv *env,
jobject thiz) {
native_data_t *nat = get_native_data(env, thiz);
// Stop by setting a flag that's used by the monitor
nat->resetStateVariables();
nat->cancel_ocr = true;
}
static void cleanupNativeDataNative(JNIEnv* env, jobject object) {
ALOGV("%s", __FUNCTION__);
#ifdef HAVE_BLUETOOTH
native_data_t *nat = get_native_data(env, object);
if (nat) {
free(nat);
}
#endif
}
static jboolean prepareListentoSocketNative(JNIEnv* env, jobject object) {
native_data_t* nat = get_native_data(env, object);
if (bt_simap_clear_socket_data() < 0) {
return JNI_FALSE;
}
return JNI_TRUE;
}
