void* SSLImpl::createStorage()
{
JNIEnv *env = jnienv();
jobject obj = env->NewObject(cls, midConstructor);
env->NewGlobalRef(obj);
return obj;
}
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");
}
}
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 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;
}
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;
}
FcmPushClient::FcmPushClient()
{
LOG(TRACE) + "FcmPushInit()";
canExecuteNotifications = false;
JNIEnv *env = jnienv();
static jclass cls = rho_find_class(env, s_FCM_FACADE_CLASS);
if (!cls) {
LOG(ERROR) + "Cannot find class: " + s_FCM_FACADE_CLASS;
return;
}
static jmethodID mid = env->GetStaticMethodID(cls, "initFireBase", "()V");
if (!mid) {
LOG(ERROR) + "Cannot get " + s_FCM_FACADE_CLASS + ".initFireBase() method";
return;
}
env->CallStaticVoidMethod(cls, mid);
CMethodResult result;
setProperty("id", s_Type, result);
setProperty("type", IPush::PUSH_TYPE_NATIVE, result);
setProperty("senderId", RHOCONF().getString("Push.fcm.senderId"), result);
setPropertyFromMethod("google_app_id", result);
//setPropertyFromMethod("google_api_key", result);
setPropertyFromMethod("gcm_defaultSenderId", result);
}
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;
}
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);
}
extern "C" const char* rho_barcode_barcode_recognize(const char* filename) {
JNIEnv *env = jnienv();
jclass cls = rho_find_class(env, "com/rhomobile/barcode/Barcode");
if (!cls) return NULL;
jmethodID mid = env->GetStaticMethodID( cls, "recognize", "(Ljava/lang/String;)Ljava/lang/String;");
if (!mid) return NULL;
jstring objFilename = env->NewStringUTF(filename);
jstring res = (jstring)env->CallStaticObjectMethod(cls, mid, objFilename);
env->DeleteLocalRef(objFilename);
if (res == NULL) {
RAWLOG_ERROR("Failed to recognize.");
return NULL;
}
if(env->GetStringUTFLength(res) < (sizeof(barcode_result)/sizeof(barcode_result[0])))
{
const char* code = env->GetStringUTFChars(res,0);
strcpy(barcode_result, code);
env->ReleaseStringUTFChars(res, code);
} else
{
RAWLOG_ERROR("Recognized data is too large.");
return NULL;
}
return barcode_result;
}
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 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);
}
}
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 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);
}
virtual void onPositionLost(RenderNode& node, const TreeInfo* info) override {
if (CC_UNLIKELY(!mWeakRef || (info && !info->updateWindowPositions))) return;
ATRACE_NAME("SurfaceView position lost");
JNIEnv* env = jnienv();
jobject localref = env->NewLocalRef(mWeakRef);
if (CC_UNLIKELY(!localref)) {
jnienv()->DeleteWeakGlobalRef(mWeakRef);
mWeakRef = nullptr;
return;
}
env->CallVoidMethod(localref, gSurfaceViewPositionLostMethod,
info ? info->canvasContext.getFrameNumber() : 0);
env->DeleteLocalRef(localref);
}
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);
}
const char * jcast_helper<const char *, jstring>::cast(jstring const &v)
{
JNIEnv *env = jnienv();
const char *s = env->GetStringUTFChars(v, JNI_FALSE);
const char *ret = ::strdup(s);
env->ReleaseStringUTFChars(v, s);
return ret;
}
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 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_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);
}
// that function return native object used for display Web content :
// UIWebView* for iPhone
// jobject for Android - jobect is android.webkit.WebView class type
// HWND for Windows Mobile
void* RhoNativeViewManager::getWebViewObject(int tab_index) {
JNIEnv *env = jnienv();
jclass cls = rho_find_class(env, "com/rhomobile/rhodes/nativeview/RhoNativeViewManager");
if (!cls) return null;
jmethodID mid = env->GetStaticMethodID( cls, "getWebViewObject", "(I)Landroid/webkit/WebView;");
if (!mid) return null;
return env->CallStaticObjectMethod(cls, mid, tab_index);
}
CURLcode SSLImpl::connect(int sockfd, int nonblocking, int *done, int ssl_verify_peer, void *storage, char* host_name)
{
if (!storage) return CURLE_SSL_CONNECT_ERROR;
jobject obj = (jobject)storage;
JNIEnv* env = jnienv();
jhstring jHostname = rho_cast<jstring>(env, host_name);
jboolean result = jnienv()->CallBooleanMethod(obj, midConnect, sockfd, (jboolean)ssl_verify_peer, (jstring)jHostname.get());
if (!result)
return CURLE_SSL_CONNECT_ERROR;
*done = 1;
return CURLE_OK;
}
AndroidImage::AndroidImage(int *count, jobject *bitmap)
:m_count(count), m_bitmap(bitmap)
{
RHO_MAP_TRACE("AndroidImage: private ctor start");
++*m_count;
init(jnienv());
RHO_MAP_TRACE("AndroidImage: private ctor finish");
}
AndroidMapDevice::~AndroidMapDevice()
{
RHO_MAP_TRACE("AndroidMapDevice: dtor start");
rho_param_free(m_params);
JNIEnv *env = jnienv();
if (m_jdevice) {
JNIEnv *env = jnienv();
jclass cls = getJNIClass(RHODES_JAVA_CLASS_MAPVIEW);
if (!cls) return;
jmethodID mid = getJNIClassMethod(env, cls, "destroyDevice", "()V");
if (!mid) return;
env->CallVoidMethod(m_jdevice, mid);
env->DeleteGlobalRef(m_jdevice);
}
RHO_MAP_TRACE("AndroidMapDevice: dtor finish");
}
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 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 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 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 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());
}
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 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());
}