extern "C" void Init_Barcode1(void)
{
JNIEnv *env = jnienv();
if(env)
{
jclass barcode1SingletonClass = rho_find_class(env, BARCODE1_SINGLETON_CLASS);
if(!barcode1SingletonClass)
{
RAWLOG_ERROR1("Failed to find java class: %s", BARCODE1_SINGLETON_CLASS);
return;
}
jmethodID midInit = env->GetStaticMethodID(barcode1SingletonClass, "init", "()V");
if(!midInit)
{
RAWLOG_ERROR1("Failed to get method 'init' for java class %s", BARCODE1_SINGLETON_CLASS);
return;
}
env->CallStaticVoidMethod(barcode1SingletonClass, midInit);
Init_RubyAPI_Barcode1();
//Init_JSAPI_Barcode1();
}
else
{
RAWLOG_ERROR("Failed to initialize Barcode1 API: jnienv() is failed");
}
}
void CHttpServer::stop()
{
// WARNING!!! It is not enough to just close listener on Android
// to stop server. By unknown reason accept does not unblock if
// it was closed in another thread. However, on iPhone it works
// right. To work around this, we create dummy socket and connect
// to the listener. This surely unblock accept on listener and,
// therefore, stop server thread (because m_active set to false).
m_active = false;
RAWLOG_INFO("Stopping server...");
SOCKET conn = socket(AF_INET, SOCK_STREAM, 0);
sockaddr_in sa;
memset(&sa, 0, sizeof(sa));
sa.sin_family = AF_INET;
sa.sin_port = htons((uint16_t)m_port);
sa.sin_addr.s_addr = inet_addr("127.0.0.1");
int err = connect(conn, (struct sockaddr *)&sa, sizeof(sa));
if (err == SOCKET_ERROR)
RAWLOG_ERROR1("Stopping server: can not connect to listener: %d", RHO_NET_ERROR_CODE);
else
RAWTRACE("Stopping server: command sent");
closesocket(conn);
/*
RAWTRACE("Close listening socket");
close_listener();
RAWTRACE("Listening socket closed");
*/
}
jobjectArray rho_cast_helper<jobjectArray, VALUE>::operator()(JNIEnv *env, VALUE value)
{
RAWTRACE("rho_cast<jobjectArray, VALUE>");
if (!initConvertor(env))
return 0;
if (NIL_P(value))
return 0;
if(TYPE(value) == T_ARRAY)
{
int size = RARRAY_LEN(value);
jobjectArray jArray = env->NewObjectArray(size, clsString, 0);
if (!jArray)
return 0;
for (int i = 0; i < size; ++i)
{
jhstring jhElement = rho_cast<jstring>(env, rb_ary_entry(value, i));
env->SetObjectArrayElement(jArray, i, jhElement.get());
}
return jArray;
}
RAWLOG_ERROR1("rho_cast<jobjectArray, VALUE>: wrong type of VALUE: %d", TYPE(value));
return 0;
}
jobjectArray rho_cast_helper<jobjectArray, VALUE>::operator()(JNIEnv *env, VALUE value)
{
RAWTRACE("rho_cast<jobjectArray, VALUE>");
if (!initConvertor(env))
return 0;
if (NIL_P(value))
return 0;
if(TYPE(value) == RUBY_T_ARRAY)
{
int size = RARRAY_LEN(value);
jobjectArray jArray = env->NewObjectArray(size, clsString, 0);
if(env->ExceptionCheck() == JNI_TRUE)
{
rho::String message = rho::common::clearException(env);
RAWLOG_ERROR(message.c_str());
return 0;
}
for (int i = 0; i < size; ++i)
{
jhstring jhElement = rho_cast<jstring>(env, rb_ary_entry(value, i));
env->SetObjectArrayElement(jArray, i, jhElement.get());
}
return jArray;
}
RAWLOG_ERROR1("rho_cast<jobjectArray, VALUE>: wrong type of VALUE: %d", TYPE(value));
return 0;
}
VALUE rho_sys_get_property(char* szPropName)
{
if (!szPropName || !*szPropName)
return rho_ruby_get_NIL();
VALUE res;
#ifdef RHODES_EMULATOR
if (rho_simimpl_get_property(szPropName, &res))
return res;
#endif
if (rho_sysimpl_get_property(szPropName, &res))
return res;
if (strcasecmp("platform",szPropName) == 0)
return rho_ruby_create_string(rho_rhodesapp_getplatform());
if (strcasecmp("has_network",szPropName) == 0)
return rho_sys_has_network();
if (strcasecmp("locale",szPropName) == 0)
return rho_sys_get_locale();
if (strcasecmp("screen_width",szPropName) == 0)
return rho_ruby_create_integer(rho_sys_get_screen_width());
if (strcasecmp("screen_height",szPropName) == 0)
return rho_ruby_create_integer(rho_sys_get_screen_height());
if (strcasecmp("device_id",szPropName) == 0)
{
rho::String strDeviceID = "";
if ( rho::sync::CClientRegister::getInstance() )
strDeviceID = rho::sync::CClientRegister::getInstance()->getDevicePin();
return rho_ruby_create_string(strDeviceID.c_str());
}
if (strcasecmp("phone_id", szPropName) == 0)
return rho_ruby_create_string("");
if (strcasecmp("full_browser",szPropName) == 0)
return rho_ruby_create_boolean(1);
if (strcasecmp("rhodes_port",szPropName) == 0)
return rho_ruby_create_integer(atoi(RHODESAPP().getFreeListeningPort()));
if (strcasecmp("is_emulator",szPropName) == 0)
return rho_ruby_create_boolean(0);
if (strcasecmp("has_touchscreen",szPropName) == 0)
return rho_ruby_create_boolean(1);
if (strcasecmp("has_sqlite",szPropName) == 0)
return rho_ruby_create_boolean(1);
RAWLOG_ERROR1("Unknown Rho::System property : %s", szPropName);
return rho_ruby_get_NIL();
}
int mapview_preload_map_tiles(const char* engine, const char* map_type, double top_latitude, double left_longitude, double bottom_latitude, double right_longitude, int min_zoom, int max_zoom, const char* callback) {
rhomap::EmptyDrawingDevice empty_device;
std::string providerId = engine;
std::transform(providerId.begin(), providerId.end(), providerId.begin(), &::tolower);
rhomap::IMapView *mapview = RHOMAPPROVIDER().createMapView(providerId, &empty_device);
if (mapview == NULL) {
RAWLOG_ERROR1("Can not create MapView for provider=%s", engine);
return 0;
}
mapview->setMapType(map_type);
mapview->set_file_caching_enable(true);
int count = mapview->preloadMapTiles(top_latitude, left_longitude, bottom_latitude, right_longitude, min_zoom, max_zoom);
CheckProgress* cp = new CheckProgress(mapview, callback, count);
cp->start(rho::common::IRhoRunnable::epNormal);
return count;
}
jclass getJNIObjectClass(JNIEnv *env, jobject obj)
{
jclass cls = env->GetObjectClass(obj);
if (!cls)
RAWLOG_ERROR1("Can not get class for object: %p (JNI)", obj);
return cls;
}
extern "C" void Init_NativeToolbar(void)
{
RAWTRACE(__FUNCTION__);
JNIEnv *env = jnienv();
if(env)
{
jclass cls = rho_find_class(env, NATIVETOOLBAR_FACTORY_CLASS);
if(!cls)
{
RAWLOG_ERROR1("Failed to find java class: %s", NATIVETOOLBAR_FACTORY_CLASS);
return;
}
jmethodID midFactory = env->GetMethodID(cls, "<init>", "()V");
if(!midFactory)
{
RAWLOG_ERROR1("Failed to get constructor for java class %s", NATIVETOOLBAR_FACTORY_CLASS);
return;
}
jobject jFactory = env->NewObject(cls, midFactory);
if(env->IsSameObject(jFactory, NULL))
{
RAWLOG_ERROR1("Failed to create %s instance", NATIVETOOLBAR_FACTORY_CLASS);
return;
}
RAWTRACE("Initializing Java factory");
rho::CNativeToolbarBase::setJavaFactory(env, jFactory);
RAWTRACE("Deleting JNI reference");
env->DeleteLocalRef(jFactory);
RAWTRACE("Initializing API");
Init_NativeToolbar_API();
RAWTRACE("Init_NativeToolbar succeeded");
}
else
{
RAWLOG_ERROR("Failed to initialize NativeToolbar API: jnienv() is failed");
}
RHODESAPP().getExtManager().requireRubyFile("RhoNativeToolbarApi");
}
extern "C" void Init_Development(void)
{
RAWTRACE(__FUNCTION__);
JNIEnv *env = jnienv();
if(env)
{
jclass cls = rho_find_class(env, DEVELOPMENT_FACTORY_CLASS);
if(!cls)
{
RAWLOG_ERROR1("Failed to find java class: %s", DEVELOPMENT_FACTORY_CLASS);
return;
}
jmethodID midFactory = env->GetMethodID(cls, "<init>", "()V");
if(!midFactory)
{
RAWLOG_ERROR1("Failed to get constructor for java class %s", DEVELOPMENT_FACTORY_CLASS);
return;
}
jobject jFactory = env->NewObject(cls, midFactory);
if(env->IsSameObject(jFactory, NULL))
{
RAWLOG_ERROR1("Failed to create %s instance", DEVELOPMENT_FACTORY_CLASS);
return;
}
RAWTRACE("Initializing Java factory");
rho::CDevelopmentBase::setJavaFactory(env, jFactory);
RAWTRACE("Deleting JNI reference");
env->DeleteLocalRef(jFactory);
RAWTRACE("Initializing API");
Init_Development_API();
RAWTRACE("Init_Development succeeded");
}
else
{
RAWLOG_ERROR("Failed to initialize Development API: jnienv() is failed");
}
}
jclass getJNIClass(int n)
{
if (n < 0 || (size_t)n >= g_classes.size())
{
RAWLOG_ERROR1("Illegal index when call getJNIClass: %d", n);
return NULL;
}
return g_classes[n];
}
static void report_error(const char *s, CFStreamError *e)
{
if (e->domain == kCFStreamErrorDomainPOSIX)
RAWLOG_ERROR2("%s, errno: %d", s, e->error);
else if (e->domain == kCFStreamErrorDomainMacOSStatus)
RAWLOG_ERROR2("%s, Mac OS status: %d", s, e->error);
else
RAWLOG_ERROR1("%s, unknown error", s);
}
//----------------------------------------------------------------------------------------------------------------------
JNIEnv* CBarcode1::jniInit()
{
JNIEnv *env = jnienv();
if(!s_class)
{
s_class = rho_find_class(env, CLASS);
if(!s_class)
{
RAWLOG_ERROR1("Failed to find java class: %s", CLASS);
s_class = 0;
return NULL;
}
s_midEnumerate = env->GetStaticMethodID(s_class, "enumerate", "(V)java/util/List;");
if(!s_midEnumerate)
{
RAWLOG_ERROR1("Failed to get method 'enumerate' for java class %s", CLASS);
s_class = 0;
return NULL;
}
s_midGetDefault = env->GetStaticMethodID(s_class, "getDefault", "()com/rhomobile/rhoelements/IBarcode1;");
if(!s_midGetDefault)
{
RAWLOG_ERROR1("Failed to get method 'getDefault' for java class %s", CLASS);
s_class = 0;
return NULL;
}
s_midSetDefaultID = env->GetStaticMethodID(s_class, "setDefaultID", "(java/util/String;)V");
if(!s_midSetDefaultID)
{
RAWLOG_ERROR1("Failed to get method 'setDefaultID' for java class %s", CLASS);
s_class = 0;
return NULL;
}
s_midCreate = env->GetStaticMethodID(s_class, "create", "(java/util/String;)com/rhomobile/rhoelements/IBarcode1;");
if(!s_midCreate)
{
RAWLOG_ERROR1("Failed to get method 'create' for java class %s", CLASS);
s_class = 0;
return NULL;
}
}
return env;
}
jclass& getJNIClass(int n)
{
static jclass jcNull = 0;
if (n < 0 || (size_t)n >= g_classes.size())
{
RAWLOG_ERROR1("Illegal index when call getJNIClass: %d", n);
return jcNull;
}
return g_classes[n];
}
extern "C" void Init_Development_extension() {
Development_Init();
JNIEnv *env = jnienv();
jclass cls = rho_find_class(env, DEVELOPMENT_CLASS);
if (!cls) {
RAWLOG_ERROR1("Failed to create %s instance", DEVELOPMENT_CLASS);
return;
}
jmethodID mid = getJNIClassStaticMethod(env, cls, "initExtension", "()V");
if (!mid) {
RAWLOG_ERROR1("Failed to get initExtension() method from %s class", DEVELOPMENT_CLASS);
return;
}
if (already_inited == 0) {
already_inited = 1;
env->CallStaticVoidMethod(cls, mid);
}
}
RHO_GLOBAL jobject JNICALL Java_com_rhomobile_rhodes_socket_SSLImpl_getRemoteSockAddr
(JNIEnv *env, jobject, jint sock)
{
jclass clsSockAddr = getJNIClass(RHODES_JAVA_CLASS_RHOSOCKADDR);
if (!clsSockAddr) return NULL;
jclass clsInetAddr = getJNIClass(RHODES_JAVA_CLASS_INET4ADDRESS);
if (!clsInetAddr) return NULL;
jmethodID midSockAddr = getJNIClassMethod(env, clsSockAddr, "<init>", "()V");
if (!midSockAddr) return NULL;
jmethodID midInetAddr = getJNIClassMethod(env, clsInetAddr, "<init>", "([BLjava/lang/String;)V");
if (!midInetAddr) return NULL;
jfieldID fidInetAddr = getJNIClassField(env, clsSockAddr, "host", "Ljava/net/InetAddress;");
if (!fidInetAddr) return NULL;
jfieldID fidPort = getJNIClassField(env, clsSockAddr, "port", "I");
if (!fidPort) return NULL;
jbyteArray array = env->NewByteArray(4);
if (!array) return NULL;
jbyte *arr = env->GetByteArrayElements(array, NULL);
if (!arr) return NULL;
sockaddr_in sa;
socklen_t salen = sizeof(sa);
int e = ::getpeername(sock, (sockaddr*)&sa, &salen);
if (e == -1) {
RAWLOG_ERROR1("getpeername failed: %d", errno);
return NULL;
}
uint32_t addr = ntohl(sa.sin_addr.s_addr);
arr[3] = (jbyte)(addr & 0xFF);
addr >>= 8;
arr[2] = (jbyte)(addr & 0xFF);
addr >>= 8;
arr[1] = (jbyte)(addr & 0xFF);
addr >>= 8;
arr[0] = (jbyte)(addr & 0xFF);
env->ReleaseByteArrayElements(array, arr, 0);
jstring ipaddrObj = rho_cast<jstring>(::inet_ntoa(sa.sin_addr));
jobject inetaddrObj = env->NewObject(clsInetAddr, midInetAddr, array, ipaddrObj);
env->DeleteLocalRef(ipaddrObj);
if (!inetaddrObj) return NULL;
jobject sockaddrObj = env->NewObject(clsSockAddr, midSockAddr);
if (!sockaddrObj) return NULL;
env->SetObjectField(sockaddrObj, fidInetAddr, inetaddrObj);
env->SetIntField(sockaddrObj, fidPort, ntohs(sa.sin_port));
env->DeleteLocalRef(inetaddrObj);
return sockaddrObj;
}
bool CHttpServer::process(SOCKET sock)
{
m_sock = sock;
// First of all, make socket non-blocking
#if defined(WINDOWS_PLATFORM)
unsigned long optval = 1;
if(::ioctlsocket(m_sock, FIONBIO, &optval) == SOCKET_ERROR) {
if (verbose) RAWLOG_ERROR1("Can not set non-blocking socket mode: %d", RHO_NET_ERROR_CODE);
return false;
}
#else
int flags = fcntl(m_sock, F_GETFL);
if (flags == -1) {
if (verbose) RAWLOG_ERROR1("Can not get current socket mode: %d", errno);
return false;
}
if (fcntl(m_sock, F_SETFL, flags | O_NONBLOCK) == -1) {
if (verbose) RAWLOG_ERROR1("Can not set non-blocking socket mode: %d", errno);
return false;
}
#endif
// Read request from socket
ByteVector request;
String method, uri, query;
HeaderList headers;
String body;
if (!parse_request(method, uri, query, headers, body)) {
if (verbose) RAWLOG_ERROR("Parsing error");
send_response(create_response("500 Internal Error"));
return false;
}
if ( !String_endsWith( uri, "js_api_entrypoint" ) )
if (verbose) RAWLOG_INFO1("Process URI: '%s'", uri.c_str());
return decide(method, uri, query, headers, body);
}
extern "C" void Init_Barcode1(void)
{
RAWTRACE("Init_Barcode1");
JNIEnv *env = jnienv();
if(env)
{
jclass cls = rho_find_class(env, BARCODE1_FACTORY_CLASS);
if(!cls)
{
RAWLOG_ERROR1("Failed to find java class: %s", BARCODE1_FACTORY_CLASS);
return;
}
jmethodID midFactory = env->GetMethodID(cls, "<init>", "()V");
if(!midFactory)
{
RAWLOG_ERROR1("Failed to get constructor for java class %s", BARCODE1_FACTORY_CLASS);
return;
}
jobject jFactory = env->NewObject(cls, midFactory);
if(env->IsSameObject(jFactory, NULL))
{
RAWLOG_ERROR1("Failed to create %s instance", BARCODE1_FACTORY_CLASS);
return;
}
rhoelements::CBarcode1::setJavaFactory(env, jFactory);
env->DeleteLocalRef(jFactory);
Init_Barcode1_API();
RAWTRACE("Init_Barcode1 succeeded");
}
else
{
RAWLOG_ERROR("Failed to initialize Barcode1 API: jnienv() is failed");
}
}
bool CHttpServer::parse_startline(String const &line, String &method, String &uri, String &query)
{
const char *s, *e;
// Find first space
for(s = line.c_str(), e = s; *e != ' ' && *e != '\0'; ++e);
if (*e == '\0') {
if (verbose) RAWLOG_ERROR1("Parse startline (1): syntax error: \"%s\"", line.c_str());
return false;
}
method.assign(s, e);
// Skip spaces
for(s = e; *s == ' '; ++s);
for(e = s; *e != '?' && *e != ' ' && *e != '\0'; ++e);
if (*e == '\0') {
if (verbose) RAWLOG_ERROR1("Parse startline (2): syntax error: \"%s\"", line.c_str());
return false;
}
uri.assign(s, e);
uri = URI::urlDecode(uri);
query.clear();
if (*e == '?') {
s = ++e;
for(e = s; *e != ' ' && *e != '\0'; ++e);
if (*e != '\0')
query.assign(s, e);
}
const char* frag = strrchr(uri.c_str(), '#');
if (frag)
uri = uri.substr(0, frag-uri.c_str());
return true;
}
bool CHttpServer::init()
{
RAWTRACE("Open listening socket...");
close_listener();
m_listener = socket(AF_INET, SOCK_STREAM, 0);
if (m_listener == INVALID_SOCKET) {
RAWLOG_ERROR1("Can not create listener: %d", RHO_NET_ERROR_CODE);
return false;
}
int enable = 1;
if (setsockopt(m_listener, SOL_SOCKET, SO_REUSEADDR, (const char *)&enable, sizeof(enable)) == SOCKET_ERROR) {
RAWLOG_ERROR1("Can not set socket option (SO_REUSEADDR): %d", RHO_NET_ERROR_CODE);
close_listener();
return false;
}
struct sockaddr_in sa;
memset(&sa, 0, sizeof(sa));
sa.sin_family = AF_INET;
sa.sin_port = htons((uint16_t)m_port);
sa.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
if (bind(m_listener, (const sockaddr *)&sa, sizeof(sa)) == SOCKET_ERROR) {
RAWLOG_ERROR2("Can not bind to port %d: %d", m_port, RHO_NET_ERROR_CODE);
close_listener();
return false;
}
if (listen(m_listener, 128) == SOCKET_ERROR) {
RAWLOG_ERROR1("Can not listen on socket: %d", RHO_NET_ERROR_CODE);
close_listener();
return false;
}
RAWLOG_INFO1("Listen for connections on port %d", m_port);
return true;
}
jdouble rho_cast_helper<jdouble, VALUE>::operator()(JNIEnv *env, VALUE value)
{
RAWTRACE("rho_cast<jdouble, VALUE>");
if (NIL_P(value))
return 0;
if(TYPE(value) == T_FLOAT)
{
return static_cast<jdouble>(RFLOAT_VALUE(value));
}
RAWLOG_ERROR1("rho_cast<jdouble, VALUE>: wrong type of VALUE: %d", TYPE(value));
return 0;
}
JNIEnv* MethodExecutorJni::jniInit()
{
JNIEnv *env = jnienv();
if(env && !s_MethodExecutorClass)
{
s_MethodExecutorClass = rho_find_class(env, METHOD_EXECUTOR_CLASS);
if(!s_MethodExecutorClass)
{
RAWLOG_ERROR1("Failed to find java class: %s", METHOD_EXECUTOR_CLASS);
s_MethodExecutorClass = 0;
return NULL;
}
s_midRun = env->GetStaticMethodID(s_MethodExecutorClass, "run", "(Ljava/lang/Runnable;)V");
if(!s_midRun)
{
RAWLOG_ERROR1("Failed to get method 'run' for java class %s", METHOD_EXECUTOR_CLASS);
s_MethodExecutorClass = 0;
return NULL;
}
s_midRunWithSeparateThread = env->GetStaticMethodID(s_MethodExecutorClass, "runWithSeparateThread", "(Ljava/lang/Runnable;)V");
if(!s_midRunWithSeparateThread)
{
RAWLOG_ERROR1("Failed to get method 'runWithSeparateThread' for java class %s", METHOD_EXECUTOR_CLASS);
s_MethodExecutorClass = 0;
return NULL;
}
s_midRunWithUiThread = env->GetStaticMethodID(s_MethodExecutorClass, "runWithUiThread", "(Ljava/lang/Runnable;)V");
if(!s_midRunWithUiThread)
{
RAWLOG_ERROR1("Failed to get method 'runWithUiThread' for java class %s", METHOD_EXECUTOR_CLASS);
s_MethodExecutorClass = 0;
return NULL;
}
}
return env;
}
jint rho_cast_helper<jint, VALUE>::operator()(JNIEnv *env, VALUE value)
{
RAWTRACE("rho_cast<jint, VALUE>");
if (NIL_P(value))
return 0;
if(TYPE(value) == T_FIXNUM)
{
return static_cast<jint>(NUM2LONG(value));
}
RAWLOG_ERROR1("rho_cast<jint, VALUE>: wrong type of VALUE: %d", TYPE(value));
return 0;
}
bool CHttpServer::parse_header(String const &line, Header &hdr)
{
const char *s, *e;
for(s = line.c_str(), e = s; *e != ' ' && *e != ':' && *e != '\0'; ++e);
if (*e == '\0') {
if (verbose) RAWLOG_ERROR1("Parse header (1): syntax error: %s", line.c_str());
return false;
}
hdr.name.assign(s, e);
// Skip spaces and colon
for(s = e; *s == ' ' || *s == ':'; ++s);
hdr.value = s;
return true;
}
VALUE require_compiled(VALUE fname, VALUE* result)
{
VALUE path;
char* szName1 = 0;
rb_funcall(fname, rb_intern("sub!"), 2, rb_str_new2(".rb"), rb_str_new2("") );
szName1 = RSTRING_PTR(fname);
if ( strcmp("strscan",szName1)==0 || strcmp("enumerator",szName1)==0 ||
strcmp("stringio",szName1)==0 || strcmp("socket",szName1)==0 ||
strcmp("digest.so",szName1)==0 || strcmp("openssl.so",szName1)==0 ||
strcmp("fcntl",szName1)==0 || strcmp("digest/md5",szName1)==0 ||
strcmp("digest/sha1",szName1)==0 )
return Qtrue;
if ( isAlreadyLoaded(fname) == Qtrue )
return Qtrue;
//RAWLOG_INFO1("find_file: %s", RSTRING_PTR(fname));
path = find_file(fname);
if ( path != 0 )
{
VALUE seq;
// if ( isAlreadyLoaded(path) == Qtrue )
// return Qtrue;
RAWLOG_INFO1("require_compiled: %s", szName1);
//optimize require
//rb_ary_push(GET_VM()->loaded_features, path);
rb_ary_push(GET_VM()->loaded_features, fname);
rb_gc_disable();
seq = loadISeqFromFile(path);
rb_gc_enable();
//*result = rb_funcall(seq, rb_intern("eval"), 0 );
*result = rb_iseq_eval(seq);
return Qtrue;
}
RAWLOG_ERROR1("require_compiled: error: can not find %s", RSTRING_PTR(fname));
return Qnil;
}
extern "C" void rho_barcode_take_barcode(const char* callback) {
JNIEnv *env = jnienv();
jclass cls = rho_find_class(env, "com/rhomobile/barcode/Barcode");
if (!cls) return;
jmethodID mid = env->GetStaticMethodID( cls, "take", "(Ljava/lang/String;)V");
if (!mid) return;
jstring objCallback = env->NewStringUTF(callback);
if(objCallback != NULL)
{
env->CallStaticObjectMethod(cls, mid, objCallback);
env->DeleteLocalRef(objCallback);
} else
{
RAWLOG_ERROR1("Cannot take barcode, no memory: %d", strlen(callback));
}
}
jdouble rho_cast_helper<jdouble, VALUE>::operator()(JNIEnv *env, VALUE value)
{
RAWTRACE("rho_cast<jdouble, VALUE>");
if (NIL_P(value))
return 0;
if(TYPE(value) == RUBY_T_FLOAT ||
TYPE(value) == RUBY_T_FIXNUM ||
TYPE(value) == RUBY_T_BIGNUM ||
TYPE(value) == RUBY_T_RATIONAL)
{
return static_cast<jdouble>(NUM2DBL(value));
}
RAWLOG_ERROR1("rho_cast<jdouble, VALUE>: wrong type of VALUE: %d", TYPE(value));
return 0;
}
jobject rho_cast_helper<jobject, VALUE>::operator()(JNIEnv *env, VALUE value)
{
RAWTRACE("rho_cast<jobject, VALUE>");
if (NIL_P(value))
return 0;
if (!initConvertor(env))
return 0;
switch(TYPE(value))
{
case RUBY_T_SYMBOL:
value = rb_funcall(value, rb_intern("to_s"), 0);
case RUBY_T_STRING:
RAWTRACE("Convert to String object");
return env->NewStringUTF(RSTRING_PTR(value));
case RUBY_T_ARRAY:
RAWTRACE("Convert to Collection object");
return convertRubyArrayToJavaCollection(value);
case RUBY_T_HASH:
RAWTRACE("Convert to Map object");
return convertRubyHashToJavaMap(value);
case RUBY_T_TRUE:
RAWTRACE("Convert to TRUE Boolean obeject");
return RhoJniConvertor::getBooleanObject(true);
case RUBY_T_FALSE:
RAWTRACE("Convert to FALSE Boolean object");
return RhoJniConvertor::getBooleanObject(false);
case RUBY_T_FIXNUM:
case RUBY_T_BIGNUM:
RAWTRACE("Convert to Integer object");
return RhoJniConvertor::getIntegerObject(NUM2LONG(value));
case RUBY_T_FLOAT:
case RUBY_T_RATIONAL:
RAWTRACE("Convert to Double object");
return RhoJniConvertor::getDoubleObject(NUM2DBL(value));
}
RAWLOG_ERROR1("rho_cast<jobject, VALUE>: wrong type of VALUE: %d", TYPE(value));
return 0;
}
VALUE rho_sys_get_property(char* szPropName)
{
if (!szPropName || !*szPropName)
return rho_ruby_get_NIL();
VALUE res = rho_sysimpl_get_property(szPropName);
if (res)
return res;
if (strcasecmp("platform",szPropName) == 0)
return rho_ruby_create_string(getPlatformProp());
if (strcasecmp("has_network",szPropName) == 0)
return rho_sys_has_network();
if (strcasecmp("locale",szPropName) == 0)
return rho_sys_get_locale();
if (strcasecmp("screen_width",szPropName) == 0)
return rho_ruby_create_integer(rho_sys_get_screen_width());
if (strcasecmp("screen_height",szPropName) == 0)
return rho_ruby_create_integer(rho_sys_get_screen_height());
if (strcasecmp("device_id",szPropName) == 0)
{
rho::String strDeviceID = "";
if ( rho::sync::CClientRegister::getInstance() )
strDeviceID = rho::sync::CClientRegister::getInstance()->getDevicePin();
return rho_ruby_create_string(strDeviceID.c_str());
}
if (strcasecmp("full_browser",szPropName) == 0)
return rho_ruby_create_boolean(1);
RAWLOG_ERROR1("Unknown Rho::System property : %s", szPropName);
return rho_ruby_get_NIL();
}
jboolean rho_cast_helper<jboolean, VALUE>::operator()(JNIEnv *env, VALUE value)
{
RAWTRACE("rho_cast<jboolean, VALUE>");
if (NIL_P(value))
return 0;
if(TYPE(value) == T_TRUE)
{
return static_cast<jboolean>(true);
}
if(TYPE(value) == T_FALSE)
{
return static_cast<jboolean>(false);
}
if(TYPE(value) == T_FIXNUM)
{
return static_cast<jboolean>(rho_ruby_get_int(value) != 0);
}
RAWLOG_ERROR1("rho_cast<jboolean, VALUE>: wrong type of VALUE: %d", TYPE(value));
return 0;
}
extern "C" void rho_barcode_take_barcode(const char* callback, VALUE options) {
JNIEnv *env = jnienv();
jclass cls = rho_find_class(env, "com/rhomobile/barcode/Barcode");
if (!cls) return;
jmethodID mid = env->GetStaticMethodID( cls, "take", "(Ljava/lang/String;I)V");
if (!mid) return;
int camera_index = 0;
if (!rho_ruby_is_NIL(options)) {
// parse options for camera index ( 0 - main, 1 - front)
rho_param *param = rho_param_fromvalue(options);
if (param->type == RHO_PARAM_HASH) {
int i;
for (i = 0; i < param->v.hash->size; i++) {
if (strcasecmp(param->v.hash->name[i], "camera") == 0) {
if (param->v.hash->value[i]->type == RHO_PARAM_STRING) {
if (strcasecmp(param->v.hash->value[i]->v.string, "front") == 0) {
camera_index = 1;
}
}
}
}
}
rho_param_free(param);
}
jstring objCallback = env->NewStringUTF(callback);
if(objCallback != NULL)
{
env->CallStaticObjectMethod(cls, mid, objCallback, camera_index);
env->DeleteLocalRef(objCallback);
} else
{
RAWLOG_ERROR1("Cannot take barcode, no memory: %d", strlen(callback));
}
}
