/* * Class: com_yahoo_ml_jcaffe_FloatBlob * Method: gpu_data * Signature: ()[F */ JNIEXPORT jobject JNICALL Java_com_yahoo_ml_jcaffe_FloatBlob_gpu_1data(JNIEnv *env, jobject object) { Blob<float>* native_ptr = NULL; try { native_ptr = (Blob<float>*) GetNativeAddress(env, object); } catch (const std::exception& ex) { ThrowJavaException(ex, env); return NULL; } jfloat* gpu_data = NULL; try { //retrieve gpu_data() gpu_data = (jfloat*)native_ptr->mutable_gpu_data(); } catch(const std::exception& ex) { ThrowJavaException(ex, env); return NULL; } if (gpu_data == NULL || env->ExceptionCheck()) { LOG(ERROR) << "gpu_data == NULL"; return NULL; } jclass claz = env->FindClass("com/yahoo/ml/jcaffe/FloatArray"); jmethodID constructorId = env->GetMethodID( claz, "<init>", "(J)V"); jobject objectFloatArray = env->NewObject(claz,constructorId,(long)gpu_data); if (env->ExceptionCheck()) { LOG(ERROR) << "FloatArray object creation failed"; return NULL; } return objectFloatArray; }
/* * Class: com_yahoo_ml_jcaffe_MatVector * Method: put * Signature: (ILcom/yahoo/ml/jcaffe/Mat;)V */ JNIEXPORT void JNICALL Java_com_yahoo_ml_jcaffe_MatVector_putnative (JNIEnv *env, jobject object, jint pos, jobject mat) { vector<cv::Mat> *native_ptr = NULL; try { native_ptr = (vector<cv::Mat>*) GetNativeAddress(env, object); } catch(const std::exception& ex) { ThrowJavaException(ex, env); return; } cv::Mat* mat_ptr = NULL; try { mat_ptr = (cv::Mat*) GetNativeAddress(env, mat); } catch(const std::exception& ex) { ThrowJavaException(ex, env); return; } if (mat_ptr==NULL) { LOG(ERROR) << "invalid native address of Mat"; ThrowCosJavaException((char*)"invalid native address of Mat", env); return; } if (pos < 0 || pos >= native_ptr->size()) { LOG(ERROR) << "invalid index in MatVector"; ThrowCosJavaException((char*)"invalid index in MatVector", env); return; } (*native_ptr)[pos] = *mat_ptr; }
JNIEXPORT void JNICALL Java_org_adblockplus_android_ABPEngine_setAcceptableAdsEnabled(JNIEnv *pEnv, jobject, jboolean enabled) { D(D_WARN, "setAcceptableAdsEnabled()"); try { const std::string surl = filterEngine->GetPref("subscriptions_exceptionsurl")->AsString(); AdblockPlus::SubscriptionPtr subscription = filterEngine->GetSubscription(surl); if (enabled == JNI_TRUE) { subscription->AddToList(); } else if (subscription->IsListed()) { subscription->RemoveFromList(); } } catch (const std::exception& e) { ThrowJavaException(pEnv, e); } catch (...) { ThrowJavaException(pEnv); } }
JNIEXPORT jobjectArray JNICALL Java_org_adblockplus_android_ABPEngine_getSelectorsForDomain(JNIEnv *pEnv, jobject, jstring domain) { try { const std::string sdomain = GetString(pEnv, domain); const std::vector<std::string> selectors = filterEngine->GetElementHidingSelectors(sdomain); static jclass cls = reinterpret_cast<jclass>(pEnv->NewGlobalRef(pEnv->FindClass("java/lang/String"))); D(D_WARN, "Selectors: %d", selectors.size()); const jobjectArray ret = (jobjectArray) pEnv->NewObjectArray(selectors.size(), cls, NULL); int i = 0; for (std::vector<std::string>::const_iterator it = selectors.begin(); it != selectors.end(); it++) { jstring selector = pEnv->NewStringUTF((*it).c_str()); pEnv->SetObjectArrayElement(ret, i, selector); pEnv->DeleteLocalRef(selector); i++; } return ret; } catch (const std::exception& e) { ThrowJavaException(pEnv, e); } catch (...) { ThrowJavaException(pEnv); } return 0; }
/* * Class: com_yahoo_ml_jcaffe_FloatBlob * Method: set_cpu_data * Signature: ([F)V */ JNIEXPORT jlong JNICALL Java_com_yahoo_ml_jcaffe_FloatBlob_set_1cpu_1data(JNIEnv *env, jobject object, jfloatArray array, jlong dataaddress) { Blob<float>* native_ptr = NULL; try { native_ptr = (Blob<float>*) GetNativeAddress(env, object); } catch (const std::exception& ex) { ThrowJavaException(ex, env); return 0; } jboolean copied = false; if (array == NULL) { LOG(ERROR) << "input array is NULL"; return 0; } float* data = env->GetFloatArrayElements(array, &copied); if (data == NULL || env->ExceptionCheck()) { LOG(ERROR) << "GetFloatArrayElements() == NULL"; return 0; } if (!copied) { size_t len = 0; try { len = native_ptr->count(); } catch (const std::exception& ex) { ThrowJavaException(ex, env); return 0; } float* new_data = new float[len]; if (new_data == NULL) { LOG(ERROR) << "fail to float[] for new data"; return 0; } memcpy(new_data, data, len * sizeof(float)); //set new data data = new_data; } try { native_ptr->set_cpu_data(data); } catch (const std::exception& ex) { ThrowJavaException(ex, env); return 0; } if(dataaddress) delete (jbyte*) dataaddress; return (long) data; }
JNIEXPORT void JNICALL Java_org_adblockplus_android_ABPEngine_initialize( JNIEnv *pEnv, jobject pObject, jstring basePath, jstring version, jstring sdkVersion, jstring locale, jboolean developmentBuild) { D(D_WARN, "nativeInitialize()"); try { int status = pEnv->GetJavaVM(&globalJvm); jniObject = pEnv->NewGlobalRef(pObject); AdblockPlus::AppInfo appInfo; appInfo.name = "adblockplusandroid"; appInfo.version = GetString(pEnv, version); appInfo.application = "android"; appInfo.applicationVersion = GetString(pEnv, sdkVersion); appInfo.locale = GetString(pEnv, locale); appInfo.developmentBuild = developmentBuild; D(D_INFO, "AppInfo: name=%s, version=%s, application=%s, applicationVersion=%s , locale=%s, developmentBuild=%s", appInfo.name.c_str(), appInfo.version.c_str(), appInfo.application.c_str(), appInfo.applicationVersion.c_str(), appInfo.locale.c_str(), appInfo.developmentBuild ? "true" : "false"); AdblockPlus::JsEnginePtr jsEngine(AdblockPlus::JsEngine::New(appInfo)); AdblockPlus::DefaultFileSystem* defaultFileSystem = new AdblockPlus::DefaultFileSystem(); AndroidLogSystem* androidLogSystem = new AndroidLogSystem(); AndroidWebRequest* androidWebRequest = new AndroidWebRequest(globalJvm); defaultFileSystem->SetBasePath(GetString(pEnv, basePath)); jsEngine->SetLogSystem(AdblockPlus::LogSystemPtr(androidLogSystem)); jsEngine->SetFileSystem(AdblockPlus::FileSystemPtr(defaultFileSystem)); jsEngine->SetWebRequest(AdblockPlus::WebRequestPtr(androidWebRequest)); jsEngine->SetEventCallback("updateAvailable", std::tr1::bind(&UpdateAvailableCallback, std::tr1::placeholders::_1)); filterEngine = new AdblockPlus::FilterEngine(jsEngine); filterEngine->SetFilterChangeCallback(&FilterChangedCallback); } catch (const std::exception& e) { ThrowJavaException(pEnv, e); } catch (...) { ThrowJavaException(pEnv); } }
JNIEXPORT jboolean JNICALL Java_org_adblockplus_android_ABPEngine_isFirstRun(JNIEnv *pEnv, jobject) { try { return filterEngine->IsFirstRun() ? JNI_TRUE : JNI_FALSE; } catch (const std::exception& e) { ThrowJavaException(pEnv, e); } catch (...) { ThrowJavaException(pEnv); } return JNI_FALSE; }
/* * Class: com_yahoo_ml_jcaffe_MatVector * Method: allocate * Signature: (I)Z */ JNIEXPORT jboolean JNICALL Java_com_yahoo_ml_jcaffe_MatVector_allocate (JNIEnv *env, jobject object, jint size) { /* create a native vector<cv::Mat*> object */ vector<cv::Mat>* native_ptr = NULL; if (size < 0) { LOG(ERROR) << "Negative MatVector size specified"; ThrowCosJavaException((char*)"Negative MatVector size specified", env); return false; } try { native_ptr = new vector<cv::Mat>(size); } catch(const std::exception& ex) { ThrowJavaException(ex, env); return false; } if (native_ptr == NULL) { LOG(ERROR) << "unable to allocate memory for vector of Mats"; return false; } /* associate native object with JVM object */ return SetNativeAddress(env, object, native_ptr); }
JNIEXPORT void JNICALL Java_org_adblockplus_android_ABPEngine_checkUpdates(JNIEnv *pEnv, jobject) { try { manualUpdate = true; filterEngine->ForceUpdateCheck(UpdaterCallback); } catch (const std::exception& e) { ThrowJavaException(pEnv, e); } catch (...) { ThrowJavaException(pEnv); } }
/* * Class: com_yahoo_ml_jcaffe_FloatBlob * Method: reshape * Signature: ([I)V */ JNIEXPORT jboolean JNICALL Java_com_yahoo_ml_jcaffe_FloatBlob_reshape (JNIEnv *env, jobject object, jintArray shape) { Blob<float>* native_ptr = NULL; try { native_ptr = (Blob<float>*) GetNativeAddress(env, object); } catch (const std::exception& ex) { ThrowJavaException(ex, env); return false; } size_t size = env->GetArrayLength(shape); if (env->ExceptionCheck()) { LOG(ERROR) << "GetArrayLength failed"; return false; } jint *vals = env->GetIntArrayElements(shape, NULL); if (vals == NULL || env->ExceptionCheck()) { LOG(ERROR) << "vals == NULL"; return false; } vector<jint> shap_vec(size); for (int i=0; i<size; i++) { if (vals[i] < 1) { LOG(ERROR) << "Invalid val for reshape dimension"; return false; } shap_vec[i] = vals[i]; } try { native_ptr->Reshape(shap_vec); } catch (const std::exception& ex) { ThrowJavaException(ex, env); return false; } //release JNI objects env->ReleaseIntArrayElements(shape, vals, JNI_ABORT); if (env->ExceptionOccurred()) { LOG(ERROR) << "Unable to release Array Elements"; return false; } return true; }
JNIEXPORT jobjectArray JNICALL Java_org_adblockplus_android_ABPEngine_getRecommendedSubscriptions(JNIEnv *pEnv, jobject) { D(D_WARN, "getRecommendedSubscriptions()"); try { const std::vector<AdblockPlus::SubscriptionPtr> subscriptions = filterEngine->FetchAvailableSubscriptions(); return subscriptionsAsJavaArray(pEnv, subscriptions); } catch (const std::exception& e) { ThrowJavaException(pEnv, e); } catch (...) { ThrowJavaException(pEnv); } return 0; }
JNIEXPORT void JNICALL Java_org_adblockplus_android_ABPEngine_actualizeSubscriptionStatus(JNIEnv *pEnv, jobject, jstring url) { D(D_WARN, "actualizeSubscriptionStatus()"); try { const std::string surl = GetString(pEnv, url); AdblockPlus::SubscriptionPtr subscription = filterEngine->GetSubscription(surl); UpdateSubscriptionStatus(subscription); } catch (const std::exception& e) { ThrowJavaException(pEnv, e); } catch (...) { ThrowJavaException(pEnv); } }
JNIEXPORT jint JNICALL Java_com_yahoo_ml_jcaffe_FloatBlob_count (JNIEnv *env, jobject object) { Blob<float>* native_ptr = NULL; try { native_ptr = (Blob<float>*) GetNativeAddress(env, object); return native_ptr->count(); } catch (const std::exception& ex) { ThrowJavaException(ex, env); return -1; } }
BOOL GetStaticMethodId(JNIEnv* env, const char* className, const char* methodName, const char* sig, jclass& clazz, jmethodID& methodId) { clazz = env->FindClass(className); if (clazz == NULL) { char msg[512]; _snprintf(msg, sizeof(msg), "Unable to %s!", className); ThrowJavaException(env, "java/lang/NullPointerException", msg); return FALSE; } methodId = env->GetStaticMethodID(clazz, methodName, sig); if (methodId == NULL) { char msg[1024]; _snprintf(msg, sizeof(msg), "Unable to find method '%s(%s)'!", methodName, sig); ThrowJavaException(env, "java/lang/NullPointerException", msg); return FALSE; } return TRUE; }
JNIEXPORT void JNICALL Java_org_adblockplus_android_ABPEngine_removeSubscription(JNIEnv *pEnv, jobject, jstring url) { D(D_WARN, "removeSubscription()"); try { const std::string surl = GetString(pEnv, url); AdblockPlus::SubscriptionPtr subscription = filterEngine->GetSubscription(surl); if (subscription->IsListed()) { subscription->RemoveFromList(); } } catch (const std::exception& e) { ThrowJavaException(pEnv, e); } catch (...) { ThrowJavaException(pEnv); } }
BOOL GetStaticObjectField(JNIEnv* env, const char* className, const char* fieldName, const char* sig, jobject& object) { jclass clazz = env->FindClass(className); if (clazz == NULL) { char msg[512]; _snprintf(msg, sizeof(msg), "Unable to %s!", className); ThrowJavaException(env, "java/lang/NullPointerException", msg); return FALSE; } jfieldID fieldId = env->GetStaticFieldID(clazz, fieldName, sig); if (fieldId == NULL) { char msg[1024]; _snprintf(msg, sizeof(msg), "Unable to find field '%s(%s)'!", fieldName, sig); ThrowJavaException(env, "java/lang/NullPointerException", msg); return FALSE; } object = env->GetStaticObjectField(clazz, fieldId); return TRUE; }
JNIEXPORT void JNICALL Java_org_adblockplus_android_ABPEngine_release(JNIEnv *pEnv, jobject) { D(D_WARN, "nativeRelease()"); try { AdblockPlus::JsEnginePtr jsEngine = filterEngine->GetJsEngine(); jsEngine->RemoveEventCallback("updateAvailable"); filterEngine->RemoveFilterChangeCallback(); delete filterEngine; pEnv->DeleteGlobalRef(jniObject); jniObject = NULL; globalJvm = NULL; } catch (const std::exception& e) { ThrowJavaException(pEnv, e); } catch (...) { ThrowJavaException(pEnv); } }
JNIEXPORT jint JNICALL Java_com_yahoo_ml_jcaffe_MatVector_channels (JNIEnv *env, jobject object, jint pos) { vector<cv::Mat> *native_ptr = NULL; try { native_ptr = (vector<cv::Mat>*) GetNativeAddress(env, object); } catch (const std::exception& ex) { ThrowJavaException(ex, env); return -1; } if (pos < 0 || pos > native_ptr->size()) { LOG(ERROR) << "Invalid Mat index in MatVector"; return -1; } cv::Mat mat = (cv::Mat)(*native_ptr)[pos]; try { return mat.channels(); } catch(const std::exception& ex) { ThrowJavaException(ex, env); return -1; } }
JNIEXPORT jboolean JNICALL Java_org_adblockplus_android_ABPEngine_matches( JNIEnv *pEnv, jobject, jstring url, jstring contentType, jobjectArray documentUrls) { try { const std::string surl = GetString(pEnv, url); const std::string stype = GetString(pEnv, contentType); const int documentUrlsLength = pEnv->GetArrayLength(documentUrls); std::vector<std::string> sdocumentUrls; for(int i = 0; i < documentUrlsLength; i++) { jstring documentUrl = static_cast<jstring>(pEnv->GetObjectArrayElement(documentUrls, i)); sdocumentUrls.push_back(GetString(pEnv, documentUrl)); } AdblockPlus::FilterPtr filter = filterEngine->Matches(surl, stype, sdocumentUrls); if (! filter) return JNI_FALSE; // hack: if there is no referrer, block only if filter is domain-specific // (to re-enable in-app ads blocking, proposed on 12.11.2012 Monday meeting) // (documentUrls contains the referrers on Android) if (!sdocumentUrls.size() && (filter->GetProperty("text")->AsString()).find("||") != std::string::npos) return JNI_FALSE; return filter->GetType() == AdblockPlus::Filter::TYPE_EXCEPTION ? JNI_FALSE : JNI_TRUE; } catch (const std::exception& e) { ThrowJavaException(pEnv, e); } catch (...) { ThrowJavaException(pEnv); } return JNI_FALSE; }
/* * Class: com_yahoo_ml_jcaffe_MatVector * Method: data * Signature: (I)[B */ JNIEXPORT jbyteArray JNICALL Java_com_yahoo_ml_jcaffe_MatVector_data (JNIEnv *env, jobject object, jint pos) { vector<cv::Mat> *native_ptr = NULL; try { native_ptr = (vector<cv::Mat>*) GetNativeAddress(env, object); } catch(const std::exception& ex) { ThrowJavaException(ex, env); return NULL; } if (pos < 0 || pos > native_ptr->size()) { LOG(ERROR) << "Invalid Mat index in MatVector"; return NULL; } cv::Mat mat = (cv::Mat)(*native_ptr)[pos]; int size = 0; try { size = mat.total() * mat.elemSize(); } catch(const std::exception& ex) { ThrowJavaException(ex, env); return NULL; } jbyteArray dataarray = env->NewByteArray(size); if(dataarray == NULL || env->ExceptionCheck()){ LOG(ERROR) << "Out of memory while allocating array for Mat data" ; return NULL; } env->SetByteArrayRegion(dataarray,0, size, (jbyte*)mat.data); if (env->ExceptionCheck()) { LOG(ERROR) << "SetByteArrayRegion failed"; return NULL; } return dataarray; }
/* * Class: com_yahoo_ml_jcaffe_FloatBlob * Method: allocate * Signature: ()V */ JNIEXPORT jboolean JNICALL Java_com_yahoo_ml_jcaffe_FloatBlob_allocate(JNIEnv *env, jobject object) { /* create a native FloatBlob object */ Blob<float>* native_ptr = NULL; try { native_ptr = new Blob<float>(); } catch(const std::exception& ex) { ThrowJavaException(ex, env); return false; } if (native_ptr == NULL) { LOG(ERROR) << "Unable to allocate memory for Blob"; return false; } /* associate native object with JVM object */ return SetNativeAddress(env, object, native_ptr); }
/* * Class: com_yahoo_ml_jcaffe_FloatBlob * Method: CopyFrom * Signature: (Lcom/yahoo/ml/jcaffe/FloatBlob;)V */ JNIEXPORT jboolean JNICALL Java_com_yahoo_ml_jcaffe_FloatBlob_copyFrom(JNIEnv *env, jobject object, jobject source) { Blob<float>* native_ptr = NULL; Blob<float>* source_ptr = NULL; if (source == NULL) { LOG(ERROR) << "source is NULL"; return false; } try { native_ptr = (Blob<float>*) GetNativeAddress(env, object); source_ptr = (Blob<float>*) GetNativeAddress(env, source); //perform operation native_ptr->CopyFrom(*source_ptr); } catch (const std::exception& ex) { ThrowJavaException(ex, env); return false; } return true; }
void ThrowJavaException(JNIEnv* env, const std::exception& e) { ThrowJavaException(env, std::string("Exception from libadblockplus: ") + e.what()); }
void ThrowJavaException(JNIEnv* env) { ThrowJavaException(env, "Unknown exception from libadblockplus"); }