RHO_GLOBAL VALUE event_fetch_by_id(const char *id)
{
JNIEnv *env = jnienv();
jclass cls = getJNIClass(RHODES_JAVA_CLASS_EVENT_STORE);
if (!cls) return Qnil;
jmethodID mid = getJNIClassStaticMethod(env, cls, "fetch", "(Ljava/lang/String;)Ljava/lang/Object;");
if (!mid) return Qnil;
jclass clsString = getJNIClass(RHODES_JAVA_CLASS_STRING);
if (!clsString) return Qnil;
RHO_TRACE("event_fetch_by_id (1)");
jhstring jId = rho_cast<jhstring>(env, id);
RHO_TRACE("event_fetch_by_id (2)");
jhobject jRet = jhobject(env->CallStaticObjectMethod(cls, mid, jId.get()));
RHO_TRACE("event_fetch_by_id (3)");
if (env->IsInstanceOf(jRet.get(), clsString))
{
RHO_TRACE("event_fetch_by_id (3.1)");
std::string error = rho_cast<std::string>(env, (jstring)jRet.get());
RHO_TRACE("event_fetch_by_id (3.2)");
rb_raise(rb_eRuntimeError, "Can't fetch event with id %s: %s", id, error.c_str());
return Qnil;
}
VALUE rEvent = event_cast<VALUE>(jRet.get());
RHO_TRACE("event_fetch_by_id (4)");
return rEvent;
}
static bool rho_cast_java_ruby_init(JNIEnv *env)
{
static rho::common::CMutex rho_fd_mtx;
static bool initialized = false;
if (initialized)
return true;
rho::common::CMutexLock guard(rho_cast_java_ruby_mtx);
if (initialized)
return true;
clsString = getJNIClass(RHODES_JAVA_CLASS_STRING);
if (!clsString) return false;
clsMap = getJNIClass(RHODES_JAVA_CLASS_MAP);
if (!clsMap) return false;
clsSet = getJNIClass(RHODES_JAVA_CLASS_SET);
if (!clsSet) return false;
clsIterator = getJNIClass(RHODES_JAVA_CLASS_ITERATOR);
if (!clsIterator) return false;
midMapGet = getJNIClassMethod(env, clsMap, "get", "(Ljava/lang/Object;)Ljava/lang/Object;");
if (!midMapGet) return false;
midMapKeySet = getJNIClassMethod(env, clsMap, "keySet", "()Ljava/util/Set;");
if (!midMapKeySet) return false;
midSetIterator = getJNIClassMethod(env, clsSet, "iterator", "()Ljava/util/Iterator;");
if (!midSetIterator) return false;
midIteratorHasNext = getJNIClassMethod(env, clsIterator, "hasNext", "()Z");
if (!midIteratorHasNext) return false;
midIteratorNext = getJNIClassMethod(env, clsIterator, "next", "()Ljava/lang/Object;");
if (!midIteratorNext) return false;
initialized = true;
return true;
}
static VALUE createHashFromContact(jobject contactObj)
{
if (logging_enable) RAWLOG_INFO("createHashFromContact() START");
JNIEnv *env = jnienv();
jclass contactCls = getJNIClass(RHODES_JAVA_CLASS_CONTACT);
if (!contactCls) return Qnil;
jclass fieldCls = getJNIClass(RHODES_JAVA_CLASS_CONTACT_FIELD);
if (!fieldCls) return Qnil;
jmethodID contactGetFieldMID = getJNIClassMethod(env, contactCls, "getField", "(I)Ljava/lang/String;");
if (!contactGetFieldMID) return Qnil;
CHoldRubyValue contactHash(rho_ruby_createHash());
// contact.moveToBegin();
int i;
for (i = 0; i < PB_FIELDS_COUNT; i++) {
jstring value = (jstring)env->CallObjectMethod(contactObj, contactGetFieldMID, i);
if (value != NULL) {
addStrToHash(contactHash, field_names[i], rho_cast<std::string>(value).c_str());
}
env->DeleteLocalRef(value);
}
if (logging_enable) RAWLOG_INFO("createHashFromContact() FINISH");
return contactHash;
}
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;
}
RHO_GLOBAL void rho_bluetooth_session_write_data(const char* connected_device_name, VALUE data) {
int size = rho_ruby_unpack_byte_array(data, 0, 0);
if (size <= 0) {
return;
}
JNIEnv *env = jnienv();
jclass cls = getJNIClass(RHODES_JAVA_CLASS_RHOBLUETOOTHMANAGER);
if (!cls) return;
jmethodID mid = getJNIClassStaticMethod(env, cls, "session_write_data", "(Ljava/lang/String;[BI)V");
if (!mid) return;
jhstring objStr1 = rho_cast<jstring>(env, connected_device_name);
jbyteArray buf_j = env->NewByteArray(size);
jbyte* buf_p = env->GetByteArrayElements(buf_j, 0);
size = rho_ruby_unpack_byte_array(data, (unsigned char*)buf_p, size);
env->ReleaseByteArrayElements(buf_j, buf_p, 0);
env->CallStaticVoidMethod(cls, mid, objStr1.get(), buf_j, size);
env->DeleteLocalRef(buf_j);
}
RHO_GLOBAL VALUE rho_bluetooth_session_read_data(const char* connected_device_name) {
JNIEnv *env = jnienv();
jclass cls = getJNIClass(RHODES_JAVA_CLASS_RHOBLUETOOTHMANAGER);
if (!cls) return 0;
jmethodID mid = getJNIClassStaticMethod(env, cls, "session_read_data", "(Ljava/lang/String;[BI)I");
if (!mid) return 0;
jhstring objStr1 = rho_cast<jstring>(env, connected_device_name);
int buf_size = env->CallStaticIntMethod(cls, mid, objStr1.get(), 0, 0);
if (buf_size == 0) {
// nothing for receive
return rho_ruby_get_NIL();
}
jholder<jbyteArray> buf_j = jholder<jbyteArray>(env->NewByteArray(buf_size));
int real_readed = env->CallStaticIntMethod(cls, mid, objStr1.get(), buf_j.get(), buf_size);
jbyte* buf_p = env->GetByteArrayElements(buf_j.get(), 0);
VALUE val = rho_ruby_create_byte_array((unsigned char*)buf_p, real_readed);
env->ReleaseByteArrayElements(buf_j.get(), buf_p, 0);
return val;
}
RHO_GLOBAL void rho_signature_take(char* callback_url, rho_param* p)
{
JNIEnv *env = jnienv();
jclass cls = getJNIClass(RHODES_JAVA_CLASS_SIGNATURE);
if (!cls) return;
jmethodID mid = getJNIClassStaticMethod(env, cls, "takeSignature", "(Ljava/lang/String;Ljava/lang/Object;)V");
if (!mid) return;
jhstring objCallback = rho_cast<jhstring>(callback_url);
/*
char* image_format = 0;
if (p)
{
rho_param* pFF = rho_param_hash_get(p, "imageFormat");
if ( pFF )
image_format = pFF->v.string;
}
if (!image_format)
image_format = "";
jhstring objFormat = rho_cast<jhstring>(image_format);
env->CallStaticVoidMethod(cls, mid, objCallback.get(), objFormat.get());
*/
jobject paramsObj = RhoValueConverter(env).createObject(p);
env->CallStaticVoidMethod(cls, mid, objCallback.get(), paramsObj);
env->DeleteLocalRef(paramsObj);
}
void MethodResultJni::callJSBack(jint jTabIndex)
{
RAWTRACE(__FUNCTION__);
jhstring jhStrCallbackID = getStrCallback(m_env);
String strCallbackID = rho_cast<String>(m_env, jhStrCallbackID.get());
jhstring jhCallbackData = getStrCallbackData(m_env);
String strCallbackData = rho_cast<String>(m_env, jhCallbackData.get());
String strRes(CMethodResultConvertor().toJSON(*this));
String strCallback("Rho.callbackHandler( \"");
strCallback += strCallbackID;
strCallback += "\", {";
strCallback += strRes;
strCallback += "},\"";
strCallback += strCallbackData;
strCallback += "\")";
jclass cls = getJNIClass(RHODES_JAVA_CLASS_WEB_VIEW);
if (!cls) return;
static jmethodID mid = getJNIClassStaticMethod(m_env, cls, "executeJs", "(Ljava/lang/String;I)V");
if (!mid) return;
jhstring jhCallback = rho_cast<jstring>(m_env, strCallback);
m_env->CallStaticVoidMethod(cls, mid, jhCallback.get(), jTabIndex);
}
RHO_GLOBAL void take_picture(char* callback_url, rho_param *options_hash )
{
JNIEnv *env = jnienv();
jclass cls = getJNIClass(RHODES_JAVA_CLASS_CAMERA);
if (!cls) return;
jmethodID mid = getJNIClassStaticMethod(env, cls, "takePicture", "(Ljava/lang/String;Ljava/lang/Object;)V");
if (!mid) return;
if ((options_hash != NULL) && (options_hash->type != RHO_PARAM_HASH)) {
RAWLOG_ERROR("Unexpected parameter type, should be Hash");
return;
}
jobject paramsObj = NULL;
if (options_hash != NULL) {
paramsObj = RhoValueConverter(env).createObject(options_hash);
}
env->CallStaticVoidMethod(cls, mid, rho_cast<jhstring>(callback_url).get(), paramsObj);
if (options_hash != NULL) {
env->DeleteLocalRef(paramsObj);
}
}
static bool init_event_stuff(JNIEnv *env)
{
static bool initialized = false;
if (initialized)
return true;
clsEvent = getJNIClass(RHODES_JAVA_CLASS_EVENT);
if (!clsEvent) return false;
fidId = getJNIClassField(env, clsEvent, "id", "Ljava/lang/String;");
if (!fidId) return false;
fidTitle = getJNIClassField(env, clsEvent, "title", "Ljava/lang/String;");
if (!fidTitle) return false;
fidStartDate = getJNIClassField(env, clsEvent, "startDate", "Ljava/util/Date;");
if (!fidStartDate) return false;
fidEndDate = getJNIClassField(env, clsEvent, "endDate", "Ljava/util/Date;");
if (!fidEndDate) return false;
fidLastModified = getJNIClassField(env, clsEvent, "lastModified", "Ljava/util/Date;");
if (!fidLastModified) return false;
fidLocation = getJNIClassField(env, clsEvent, "location", "Ljava/lang/String;");
if (!fidLocation) return false;
fidNotes = getJNIClassField(env, clsEvent, "notes", "Ljava/lang/String;");
if (!fidNotes) return false;
fidPrivacy = getJNIClassField(env, clsEvent, "privacy", "Ljava/lang/String;");
if (!fidPrivacy) return false;
fidFrequency = getJNIClassField(env, clsEvent, "frequency", "Ljava/lang/String;");
if (!fidFrequency) return false;
fidInterval = getJNIClassField(env, clsEvent, "interval", "I");
if (!fidInterval) return false;
initialized = true;
return true;
}
RHO_GLOBAL void JNICALL Java_com_rhomobile_rhodes_file_RhoFileApi_updateStatTable
(JNIEnv *env, jclass, jstring pathObj, jstring type, jlong size, jlong mtime)
{
std::string path = rho_cast<std::string>(env, pathObj);
rho_stat_t st;
std::string t = rho_cast<std::string>(env, type);
if (t == "dir")
st.type = rho_type_dir;
else if (t == "file")
st.type = rho_type_file;
else
{
jclass clsRE = getJNIClass(RHODES_JAVA_CLASS_RUNTIME_EXCEPTION);
if (!clsRE) return;
env->ThrowNew(clsRE, "Unknown type of file");
return;
}
st.size = (size_t)size;
st.mtime = (unsigned long)mtime;
rho_stat_map.insert(std::make_pair(path, st));
if (st.type == rho_type_dir)
{
std::string fpath = rho_root_path() + "/" + path;
RHO_LOG("updateStatTable: create dir: %s", fpath.c_str());
mkdir(fpath.c_str(), S_IRWXU);
}
}
VALUE rho_cast_helper<VALUE, jobject>::operator()(JNIEnv *env, jobject obj)
{
if (env->IsSameObject(obj, NULL) == JNI_TRUE)
return Qnil;
if (!initConvertor(env))
{
env->ThrowNew(getJNIClass(RHODES_JAVA_CLASS_RUNTIME_EXCEPTION), "Java <=> Ruby conversion initialization failed");
return Qnil;
}
if (env->IsInstanceOf(obj, clsString))
{
const char *str = env->GetStringUTFChars(static_cast<jstring>(obj), JNI_FALSE);
VALUE res = rho_ruby_create_string(str);
env->ReleaseStringUTFChars(static_cast<jstring>(obj), str);
return res;
}
if (env->IsInstanceOf(obj, clsMap))
return convertJavaMapToRubyHash(env, obj);
RAWLOG_ERROR("rho_cast<VALUE, jobject>: unknown type of value");
return Qnil;
}
static VALUE getRecord(void *pb, const char *name)
{
if (logging_enable) RAWLOG_INFO("getRecord() START");
jobject obj = (jobject)pb;
JNIEnv *env = jnienv();
if (!env) {
if (logging_enable) RAWLOG_INFO("getRecord() FINISH return NIL0");
return Qnil;
}
jclass cls = getJNIClass(RHODES_JAVA_CLASS_PHONEBOOK);
if (!cls) {
if (logging_enable) RAWLOG_INFO("getRecord() FINISH return NIL1");
return Qnil;
}
jmethodID mid = getJNIClassMethod(env, cls, name, "()Lcom/rhomobile/rhodes/phonebook/Contact;");
if (!mid) {
if (logging_enable) RAWLOG_INFO("getRecord() FINISH return NIL2");
return Qnil;
}
jobject recordObj = env->CallObjectMethod(obj, mid);
if (!recordObj) {
if (logging_enable) RAWLOG_INFO("getRecord() FINISH return NIL");
return Qnil;
}
if (logging_enable) RAWLOG_INFO("getRecord() FINISH");
return createHashFromContact(recordObj);
}
//----------------------------------------------------------------------------------------------------------------------
void rhoconnect_jni_fill_objectnotify(JNIEnv * env, jobject jNotify, int cnt, const char* const * objects, int* src_ids,
jfieldID fidObjects, jfieldID fidSrcIds)
{
static jclass clsString = getJNIClass(RHODES_JAVA_CLASS_STRING);
if (!clsString) return;
LOG(TRACE) + "rhoconnect_jni_fill_objectnotify: cnt: " + cnt + ", Java notify reference: " + (int)jNotify;
if(cnt > 0)
{
jobjectArray jObjects = env->NewObjectArray(cnt, clsString, NULL);
if (!jObjects) return;
jintArray jSrcIds = env->NewIntArray(cnt);
if (!jSrcIds) return;
for(int i = 0; i < cnt; ++i)
{
jhstring jhObject = rho_cast<jhstring>(env, objects[i]);
env->SetObjectArrayElement(jObjects, i, jhObject.release());
}
env->SetIntArrayRegion(jSrcIds, 0, cnt, src_ids);
env->SetObjectField(jNotify, fidObjects, jObjects);
env->SetObjectField(jNotify, fidSrcIds, jSrcIds);
}
}
static bool set_capabilities(JNIEnv *env)
{
RAWTRACE("Capabilities setup");
char const *caps[] = {
#define RHO_DEFINE_CAP(x) #x,
#include "rhocaps.inc"
#undef RHO_DEFINE_CAP
};
std::map<std::string, bool> actual_caps;
#define RHO_DEFINE_CAP(x) actual_caps[#x] = RHO_CAP_ ## x ## _ENABLED;
#include "rhocaps.inc"
#undef RHO_DEFINE_CAP
jclass cls = getJNIClass(RHODES_JAVA_CLASS_CAPABILITIES);
if (!cls) return false;
for (size_t i = 0, lim = sizeof(caps)/sizeof(caps[0]); i < lim; ++i)
{
std::string field_name = std::string(caps[i]) + "_ENABLED";
RAWTRACE2("%s->%d", field_name.c_str(), static_cast<int>(actual_caps[caps[i]]));
jfieldID fid = getJNIClassStaticField(env, cls, field_name.c_str(), "Z");
if (!fid) return false;
env->SetStaticBooleanField(cls, fid, actual_caps[caps[i]]);
}
return true;
}
RHO_GLOBAL const char* event_save(VALUE rEvent)
{
JNIEnv *env = jnienv();
jclass cls = getJNIClass(RHODES_JAVA_CLASS_EVENT_STORE);
if (!cls) return NULL;
jmethodID mid = getJNIClassStaticMethod(env, cls, "save", "(Lcom/rhomobile/rhodes/event/Event;)Ljava/lang/String;");
if (!mid) return NULL;
jobject jEvent = event_cast<jobject>(rEvent);
jstring new_id = (jstring)env->CallStaticObjectMethod(cls, mid, jEvent);
env->DeleteLocalRef(jEvent);
//if (jError)
//{
// std::string error = rho_cast<std::string>(env, jError);
// env->DeleteLocalRef(jError);
// rb_raise(rb_eRuntimeError, "Event save failed: %s", error.c_str());
//}
if (new_id) {
return_string = rho_cast<std::string>(env, new_id);
env->DeleteLocalRef(new_id);
return return_string.c_str();
}
return NULL;
}
RHO_GLOBAL VALUE get_camera_info(const char* camera_type) {
JNIEnv *env = jnienv();
jclass cls = getJNIClass(RHODES_JAVA_CLASS_CAMERA);
if (!cls) return rho_ruby_get_NIL();
jmethodID mid_w = getJNIClassStaticMethod(env, cls, "getMaxCameraWidth", "(Ljava/lang/String;)I");
jmethodID mid_h = getJNIClassStaticMethod(env, cls, "getMaxCameraHeight", "(Ljava/lang/String;)I");
if ((!mid_w) || (!mid_h)) return rho_ruby_get_NIL();
int w = env->CallStaticIntMethod(cls, mid_w, rho_cast<jhstring>(camera_type).get());
int h = env->CallStaticIntMethod(cls, mid_h, rho_cast<jhstring>(camera_type).get());
if ((w <= 0) || (h <= 0)) {
return rho_ruby_get_NIL();
}
VALUE hash = rho_ruby_createHash();
VALUE hash_max_resolution = rho_ruby_createHash();
rho_ruby_add_to_hash(hash_max_resolution, rho_ruby_create_string("width"), rho_ruby_create_integer(w));
rho_ruby_add_to_hash(hash_max_resolution, rho_ruby_create_string("height"), rho_ruby_create_integer(h));
rho_ruby_add_to_hash(hash, rho_ruby_create_string("max_resolution"), hash_max_resolution);
return hash;
}
//--------------------------------------------------------------------------------------------------
RHO_GLOBAL void android_setup(JNIEnv *env)
{
jclass clsRE = getJNIClass(RHODES_JAVA_CLASS_RUNTIME_EXCEPTION);
if (!clsRE)
return;
// Init logconf
rho_logconf_Init(rho_log_path().c_str(), rho_root_path().c_str(), "");
if (rho_root_path().compare(rho_shared_path()) != 0)
{
rho_conf_Init_from_shared_path(rho_shared_path().c_str());
}
if(!(RHOCONF().isExist("useAssetFS")) || RHOCONF().getBool("useAssetFS")) {
struct rlimit rlim;
if (getrlimit(RLIMIT_NOFILE, &rlim) == -1)
{
env->ThrowNew(clsRE, "Can not get maximum number of open files");
return;
}
if (rlim.rlim_max < (unsigned long)RHO_FD_BASE)
{
env->ThrowNew(clsRE, "Current limit of open files is less then RHO_FD_BASE");
return;
}
if (rlim.rlim_cur > (unsigned long)RHO_FD_BASE)
{
rlim.rlim_cur = RHO_FD_BASE;
rlim.rlim_max = RHO_FD_BASE;
if (setrlimit(RLIMIT_NOFILE, &rlim) == -1)
{
env->ThrowNew(clsRE, "Can not set maximum number of open files");
return;
}
}
}
if (!set_posix_environment(env, clsRE)) return;
if (::chdir(rho_root_path().c_str()) == -1)
{
env->ThrowNew(clsRE, "Can not chdir to HOME directory");
return;
}
// Init SQLite temp directory
sqlite3_temp_directory = (char*)s_sqlite_path.c_str();
// Disable log to stdout as on android all stdout redirects to /dev/null
RHOCONF().setBool("LogToOutput", false, true);
LOGCONF().setLogToOutput(false);
// Add android system log sink
LOGCONF().setLogView(s_logSink);
LOGCONF().setMemoryInfoCollector(s_memory_info_collector);
}
RHO_GLOBAL void rho_bluetooth_off_bluetooth() {
JNIEnv *env = jnienv();
jclass cls = getJNIClass(RHODES_JAVA_CLASS_RHOBLUETOOTHMANAGER);
if (!cls) return;
jmethodID mid = getJNIClassStaticMethod(env, cls, "off_bluetooth", "()V");
if (!mid) return;
env->CallStaticVoidMethod(cls, mid);
}
RHO_GLOBAL int rho_sys_set_sleeping(int sleeping) {
JNIEnv *env = jnienv();
jclass cls = getJNIClass(RHODES_JAVA_CLASS_RHODES_SERVICE);
if (!cls) return 0;
jmethodID mid = getJNIClassStaticMethod(env, cls, "rho_sys_set_sleeping", "(I)I");
if (!mid) return 0;
return env->CallStaticIntMethod(cls, mid, sleeping);
}
RHO_GLOBAL int rho_bluetooth_is_bluetooth_available() {
JNIEnv *env = jnienv();
jclass cls = getJNIClass(RHODES_JAVA_CLASS_RHOBLUETOOTHMANAGER);
if (!cls) return 0;
jmethodID mid = getJNIClassStaticMethod(env, cls, "is_bluetooth_available", "()I");
if (!mid) return 0;
return env->CallStaticIntMethod(cls, mid);
}
RhoValueConverter::RhoValueConverter(JNIEnv *e)
:env(e), init(false)
{
clsHashMap = getJNIClass(RHODES_JAVA_CLASS_HASHMAP);
if (!clsHashMap) return;
clsVector = getJNIClass(RHODES_JAVA_CLASS_VECTOR);
if (!clsVector) return;
midHashMapConstructor = getJNIClassMethod(env, clsHashMap, "<init>", "()V");
if (!midHashMapConstructor) return;
midVectorConstructor = getJNIClassMethod(env, clsVector, "<init>", "()V");
if (!midVectorConstructor) return;
midPut = getJNIClassMethod(env, clsHashMap, "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
if (!midPut) return;
midAddElement = getJNIClassMethod(env, clsVector, "addElement", "(Ljava/lang/Object;)V");
if (!midAddElement) return;
init = true;
}
RHO_GLOBAL void ringtone_manager_stop()
{
jclass cls = getJNIClass(RHODES_JAVA_CLASS_RINGTONE_MANAGER);
if (!cls) return;
jmethodID mid = getJNIClassStaticMethod(cls, "stop", "()V");
if (!mid) return;
jnienv()->CallStaticVoidMethod(cls, mid);
}
RHO_GLOBAL int rho_sys_is_app_installed(const char *appname)
{
JNIEnv *env = jnienv();
jclass cls = getJNIClass(RHODES_JAVA_CLASS_RHODES_SERVICE);
if (!cls) return 0;
jmethodID mid = getJNIClassStaticMethod(env, cls, "isAppInstalled", "(Ljava/lang/String;)Z");
if (!mid) return 0;
return (int)env->CallStaticBooleanMethod(cls, mid, rho_cast<jhstring>(appname).get());
}
RHO_GLOBAL void rho_sys_app_uninstall(const char *appname)
{
JNIEnv *env = jnienv();
jclass cls = getJNIClass(RHODES_JAVA_CLASS_RHODES_SERVICE);
if (!cls) return;
jmethodID mid = getJNIClassStaticMethod(env, cls, "uninstallApplication", "(Ljava/lang/String;)V");
if (!mid) return;
env->CallStaticVoidMethod(cls, mid, rho_cast<jhstring>(appname).get());
}
RHO_GLOBAL VALUE rho_sys_has_network()
{
JNIEnv *env = jnienv();
jclass cls = getJNIClass(RHODES_JAVA_CLASS_RHODES);
if (!cls) return rho_ruby_create_boolean(0);
jmethodID mid = getJNIClassStaticMethod(env, cls, "hasNetwork", "()Z");
if (!mid) return rho_ruby_create_boolean(0);
return rho_ruby_create_boolean(env->CallStaticBooleanMethod(cls, mid));
}
RHO_GLOBAL void rho_sys_app_exit()
{
JNIEnv *env = jnienv();
jclass cls = getJNIClass(RHODES_JAVA_CLASS_RHODES);
if (!cls) return;
jmethodID mid = getJNIClassStaticMethod(env, cls, "exit", "()V");
if (!mid) return;
env->CallStaticVoidMethod(cls, mid);
}
RHO_GLOBAL int rho_net_ping_network(const char* szHost)
{
JNIEnv *env = jnienv();
jclass cls = getJNIClass(RHODES_JAVA_CLASS_RHODES_SERVICE);
if (!cls) return 0;
jmethodID mid = getJNIClassStaticMethod(env, cls, "pingHost", "(Ljava/lang/String;)Z");
if (!mid) return 0;
return (int)env->CallStaticBooleanMethod(cls, mid, rho_cast<jhstring>(szHost).get());
}
RHO_GLOBAL void alert_hide_popup()
{
JNIEnv *env = jnienv();
jclass cls = getJNIClass(RHODES_JAVA_CLASS_ALERT);
if (!cls) return;
jmethodID mid = getJNIClassStaticMethod(env, cls, "hidePopup", "()V");
if (!mid) return;
env->CallStaticVoidMethod(cls, mid);
}
RHO_GLOBAL void choose_picture(char* callback_url, rho_param *options_hash)
{
JNIEnv *env = jnienv();
jclass cls = getJNIClass(RHODES_JAVA_CLASS_CAMERA);
if (!cls) return;
jmethodID mid = getJNIClassStaticMethod(env, cls, "choosePicture", "(Ljava/lang/String;)V");
if (!mid) return;
env->CallStaticVoidMethod(cls, mid, rho_cast<jhstring>(callback_url).get());
}
