/*
* 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");
}
