| OLD | NEW | 
|---|
|  | (Empty) | 
| 1 /* |  | 
| 2  * This file is part of Adblock Plus <http://adblockplus.org/>, |  | 
| 3  * Copyright (C) 2006-2014 Eyeo GmbH |  | 
| 4  * |  | 
| 5  * Adblock Plus is free software: you can redistribute it and/or modify |  | 
| 6  * it under the terms of the GNU General Public License version 3 as |  | 
| 7  * published by the Free Software Foundation. |  | 
| 8  * |  | 
| 9  * Adblock Plus is distributed in the hope that it will be useful, |  | 
| 10  * but WITHOUT ANY WARRANTY; without even the implied warranty of |  | 
| 11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the |  | 
| 12  * GNU General Public License for more details. |  | 
| 13  * |  | 
| 14  * You should have received a copy of the GNU General Public License |  | 
| 15  * along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>. |  | 
| 16  */ |  | 
| 17 |  | 
| 18 #include <jni.h> |  | 
| 19 #include <AdblockPlus.h> |  | 
| 20 #include "AndroidLogSystem.h" |  | 
| 21 #include "AndroidWebRequest.h" |  | 
| 22 #include "Utils.h" |  | 
| 23 #include "Debug.h" |  | 
| 24 |  | 
| 25 JavaVM* globalJvm; |  | 
| 26 AdblockPlus::FilterEngine* filterEngine; |  | 
| 27 jobject jniObject; |  | 
| 28 bool manualUpdate = false; |  | 
| 29 |  | 
| 30 extern "C" |  | 
| 31 { |  | 
| 32   JNIEXPORT void JNICALL Java_org_adblockplus_android_ABPEngine_initialize( |  | 
| 33     JNIEnv *pEnv, jobject object, jstring basePath, jstring version, |  | 
| 34     jstring sdkVersion, jstring locale, jboolean developmentBuild); |  | 
| 35   JNIEXPORT void JNICALL Java_org_adblockplus_android_ABPEngine_release(JNIEnv *
     pEnv, jobject); |  | 
| 36   JNIEXPORT jboolean JNICALL Java_org_adblockplus_android_ABPEngine_isFirstRun(J
     NIEnv *pEnv, jobject); |  | 
| 37   JNIEXPORT jobjectArray JNICALL Java_org_adblockplus_android_ABPEngine_getListe
     dSubscriptions(JNIEnv *pEnv, jobject); |  | 
| 38   JNIEXPORT jobjectArray JNICALL Java_org_adblockplus_android_ABPEngine_getRecom
     mendedSubscriptions(JNIEnv *pEnv, jobject); |  | 
| 39   JNIEXPORT void JNICALL Java_org_adblockplus_android_ABPEngine_addSubscription(
     JNIEnv *pEnv, jobject, jstring url); |  | 
| 40   JNIEXPORT void JNICALL Java_org_adblockplus_android_ABPEngine_removeSubscripti
     on(JNIEnv *pEnv, jobject, jstring url); |  | 
| 41   JNIEXPORT void JNICALL Java_org_adblockplus_android_ABPEngine_refreshSubscript
     ion(JNIEnv *pEnv, jobject, jstring url); |  | 
| 42   JNIEXPORT void JNICALL Java_org_adblockplus_android_ABPEngine_actualizeSubscri
     ptionStatus(JNIEnv *pEnv, jobject, jstring url); |  | 
| 43   JNIEXPORT void JNICALL Java_org_adblockplus_android_ABPEngine_setAcceptableAds
     Enabled(JNIEnv *pEnv, jobject, jboolean enabled); |  | 
| 44   JNIEXPORT jstring JNICALL Java_org_adblockplus_android_ABPEngine_getDocumentat
     ionLink( |  | 
| 45       JNIEnv *env, jobject object); |  | 
| 46   JNIEXPORT jboolean JNICALL Java_org_adblockplus_android_ABPEngine_matches( |  | 
| 47       JNIEnv *pEnv, jobject, jstring url, jstring contentType, jobjectArray docu
     mentUrls); |  | 
| 48   JNIEXPORT jobjectArray JNICALL Java_org_adblockplus_android_ABPEngine_getSelec
     torsForDomain(JNIEnv *pEnv, jobject, jstring domain); |  | 
| 49   JNIEXPORT void JNICALL Java_org_adblockplus_android_ABPEngine_checkUpdates(JNI
     Env *pEnv, jobject); |  | 
| 50 }; |  | 
| 51 |  | 
| 52 jobjectArray subscriptionsAsJavaArray(JNIEnv *pEnv, std::vector<AdblockPlus::Sub
     scriptionPtr> subscriptions) |  | 
| 53 { |  | 
| 54   D(D_WARN, "subscriptionsAsJavaArray()"); |  | 
| 55   static jclass cls = reinterpret_cast<jclass>(pEnv->NewGlobalRef(pEnv->FindClas
     s("org/adblockplus/android/Subscription"))); |  | 
| 56   static jmethodID cid = pEnv->GetMethodID(cls, "<init>", "()V"); |  | 
| 57   static jfieldID ftitle = pEnv->GetFieldID(cls, "title", "Ljava/lang/String;"); |  | 
| 58   static jfieldID furl = pEnv->GetFieldID(cls, "url", "Ljava/lang/String;"); |  | 
| 59 |  | 
| 60   const std::string surl = filterEngine->GetPref("subscriptions_exceptionsurl")-
     >AsString(); |  | 
| 61   AdblockPlus::SubscriptionPtr acceptableAdsSubscription = filterEngine->GetSubs
     cription(surl); |  | 
| 62 |  | 
| 63   int size = subscriptions.size(); |  | 
| 64   for (std::vector<AdblockPlus::SubscriptionPtr>::const_iterator it = subscripti
     ons.begin(); |  | 
| 65        it != subscriptions.end(); it++) |  | 
| 66   { |  | 
| 67     if (*acceptableAdsSubscription == **it) |  | 
| 68       size--; |  | 
| 69   } |  | 
| 70 |  | 
| 71   const jobjectArray ret = (jobjectArray) pEnv->NewObjectArray(size, cls, NULL); |  | 
| 72 |  | 
| 73   int i = 0; |  | 
| 74   for (std::vector<AdblockPlus::SubscriptionPtr>::const_iterator it = subscripti
     ons.begin(); |  | 
| 75        it != subscriptions.end(); it++) |  | 
| 76   { |  | 
| 77     if (*acceptableAdsSubscription == **it) |  | 
| 78       continue; |  | 
| 79     jobject subscription = pEnv->NewObject(cls, cid); |  | 
| 80     pEnv->SetObjectField(subscription, ftitle, pEnv->NewStringUTF((*it)->GetProp
     erty("title")->AsString().c_str())); |  | 
| 81     pEnv->SetObjectField(subscription, furl, pEnv->NewStringUTF((*it)->GetProper
     ty("url")->AsString().c_str())); |  | 
| 82     pEnv->SetObjectArrayElement(ret, i, subscription); |  | 
| 83     i++; |  | 
| 84   } |  | 
| 85 |  | 
| 86   return ret; |  | 
| 87 } |  | 
| 88 |  | 
| 89 void UpdateSubscriptionStatus(const AdblockPlus::SubscriptionPtr subscription) |  | 
| 90 { |  | 
| 91   D(D_WARN, "UpdateSubscriptionStatus()"); |  | 
| 92 |  | 
| 93   std::string downloadStatus = subscription->GetProperty("downloadStatus")->IsNu
     ll() ? "" : subscription->GetProperty("downloadStatus")->AsString(); |  | 
| 94   int64_t lastDownload = subscription->GetProperty("lastDownload")->AsInt(); |  | 
| 95 |  | 
| 96   std::string status = "synchronize_never"; |  | 
| 97   int64_t time = 0; |  | 
| 98 |  | 
| 99   if (subscription->IsUpdating()) |  | 
| 100   { |  | 
| 101     status = "synchronize_in_progress"; |  | 
| 102   } |  | 
| 103   else if (!downloadStatus.empty() && downloadStatus != "synchronize_ok") |  | 
| 104   { |  | 
| 105     status = downloadStatus; |  | 
| 106   } |  | 
| 107   else if (lastDownload > 0) |  | 
| 108   { |  | 
| 109     time = lastDownload; |  | 
| 110     status = "synchronize_last_at"; |  | 
| 111   } |  | 
| 112 |  | 
| 113   JNIEnv* jniEnv = NULL; |  | 
| 114   int stat = globalJvm->GetEnv((void **)&jniEnv, JNI_VERSION_1_6); |  | 
| 115   if (stat == JNI_EDETACHED) |  | 
| 116   { |  | 
| 117     if (globalJvm->AttachCurrentThread(&jniEnv, NULL) != 0) |  | 
| 118       throw std::runtime_error("Failed to get JNI environment"); |  | 
| 119   } |  | 
| 120 |  | 
| 121   jstring jUrl = jniEnv->NewStringUTF(subscription->GetProperty("url")->AsString
     ().c_str()); |  | 
| 122   jstring jStatus = jniEnv->NewStringUTF(status.c_str()); |  | 
| 123   jlong jTime = time * 1000; |  | 
| 124 |  | 
| 125   static jclass cls = jniEnv->GetObjectClass(jniObject); |  | 
| 126   static jmethodID mid = jniEnv->GetMethodID(cls, "onFilterChanged", "(Ljava/lan
     g/String;Ljava/lang/String;J)V"); |  | 
| 127   if (mid) |  | 
| 128     jniEnv->CallVoidMethod(jniObject, mid, jUrl, jStatus, jTime); |  | 
| 129   jniEnv->DeleteLocalRef(jUrl); |  | 
| 130   jniEnv->DeleteLocalRef(jStatus); |  | 
| 131 |  | 
| 132   if (stat == JNI_EDETACHED) |  | 
| 133     globalJvm->DetachCurrentThread(); |  | 
| 134 } |  | 
| 135 |  | 
| 136 void FilterChangedCallback(const std::string& action, const AdblockPlus::JsValue
     Ptr item) |  | 
| 137 { |  | 
| 138   D(D_WARN, "FilterChangedCallback()"); |  | 
| 139 |  | 
| 140   if (action == "subscription.lastDownload" || action == "subscription.downloadS
     tatus") |  | 
| 141   { |  | 
| 142     AdblockPlus::SubscriptionPtr subscription = AdblockPlus::SubscriptionPtr(new
      AdblockPlus::Subscription(item)); |  | 
| 143     UpdateSubscriptionStatus(subscription); |  | 
| 144   } |  | 
| 145 } |  | 
| 146 |  | 
| 147 void UpdateAvailableCallback(AdblockPlus::JsValueList& params) |  | 
| 148 { |  | 
| 149   D(D_WARN, "UpdateAvailableCallback()"); |  | 
| 150   std::string updateUrl(params.size() >= 1 && !params[0]->IsNull() ? params[0]->
     AsString() : ""); |  | 
| 151   if (updateUrl.empty()) |  | 
| 152     return; |  | 
| 153 |  | 
| 154   JNIEnv* jniEnv = NULL; |  | 
| 155   int stat = globalJvm->GetEnv((void **)&jniEnv, JNI_VERSION_1_6); |  | 
| 156   if (stat == JNI_EDETACHED) |  | 
| 157   { |  | 
| 158     if (globalJvm->AttachCurrentThread(&jniEnv, NULL) != 0) |  | 
| 159       throw std::runtime_error("Failed to get JNI environment"); |  | 
| 160   } |  | 
| 161 |  | 
| 162   jstring jUrl = jniEnv->NewStringUTF(updateUrl.c_str()); |  | 
| 163 |  | 
| 164   static jclass cls = jniEnv->GetObjectClass(jniObject); |  | 
| 165   static jmethodID mid = jniEnv->GetMethodID(cls, "onUpdateEvent", "(Ljava/lang/
     String;Ljava/lang/String;)V"); |  | 
| 166   if (mid) |  | 
| 167     jniEnv->CallVoidMethod(jniObject, mid, jUrl, NULL); |  | 
| 168   jniEnv->DeleteLocalRef(jUrl); |  | 
| 169 |  | 
| 170   if (stat == JNI_EDETACHED) |  | 
| 171     globalJvm->DetachCurrentThread(); |  | 
| 172 } |  | 
| 173 |  | 
| 174 void UpdaterCallback(const std::string& error) |  | 
| 175 { |  | 
| 176   JNIEnv* jniEnv = NULL; |  | 
| 177   int stat = globalJvm->GetEnv((void **)&jniEnv, JNI_VERSION_1_6); |  | 
| 178   if (stat == JNI_EDETACHED) |  | 
| 179   { |  | 
| 180     if (globalJvm->AttachCurrentThread(&jniEnv, NULL) != 0) |  | 
| 181       throw std::runtime_error("Failed to get JNI environment"); |  | 
| 182   } |  | 
| 183 |  | 
| 184   static jclass cls = jniEnv->GetObjectClass(jniObject); |  | 
| 185   static jmethodID mid = jniEnv->GetMethodID(cls, "onUpdateEvent", "(Ljava/lang/
     String;Ljava/lang/String;)V"); |  | 
| 186 |  | 
| 187   if (!error.empty()) |  | 
| 188   { |  | 
| 189     jstring jError = jniEnv->NewStringUTF(error.c_str()); |  | 
| 190     if (mid) |  | 
| 191       jniEnv->CallVoidMethod(jniObject, mid, NULL, jError); |  | 
| 192     jniEnv->DeleteLocalRef(jError); |  | 
| 193   } |  | 
| 194   else if (manualUpdate) |  | 
| 195   { |  | 
| 196     if (mid) |  | 
| 197       jniEnv->CallVoidMethod(jniObject, mid, NULL, NULL); |  | 
| 198   } |  | 
| 199 |  | 
| 200   if (stat == JNI_EDETACHED) |  | 
| 201     globalJvm->DetachCurrentThread(); |  | 
| 202 } |  | 
| 203 |  | 
| 204 void ThrowJavaException(JNIEnv* env, const std::string& message) |  | 
| 205 { |  | 
| 206   jclass exceptionClass = env->FindClass("java/lang/Exception"); |  | 
| 207   env->ThrowNew(exceptionClass, message.c_str()); |  | 
| 208 } |  | 
| 209 |  | 
| 210 void ThrowJavaException(JNIEnv* env, const std::exception& e) |  | 
| 211 { |  | 
| 212   ThrowJavaException(env, std::string("Exception from libadblockplus: ") + e.wha
     t()); |  | 
| 213 } |  | 
| 214 |  | 
| 215 void ThrowJavaException(JNIEnv* env) |  | 
| 216 { |  | 
| 217   ThrowJavaException(env, "Unknown exception from libadblockplus"); |  | 
| 218 } |  | 
| 219 |  | 
| 220 jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved) |  | 
| 221 { |  | 
| 222   return JNI_VERSION_1_6; |  | 
| 223 } |  | 
| 224 |  | 
| 225 void JNICALL JNI_OnUnload(JavaVM *vm, void *reserved) |  | 
| 226 { |  | 
| 227 } |  | 
| 228 |  | 
| 229 JNIEXPORT void JNICALL Java_org_adblockplus_android_ABPEngine_initialize( |  | 
| 230   JNIEnv *pEnv, jobject pObject, jstring basePath, jstring version, |  | 
| 231   jstring sdkVersion, jstring locale, jboolean developmentBuild) |  | 
| 232 { |  | 
| 233   D(D_WARN, "nativeInitialize()"); |  | 
| 234   try |  | 
| 235   { |  | 
| 236     int status = pEnv->GetJavaVM(&globalJvm); |  | 
| 237 |  | 
| 238     jniObject = pEnv->NewGlobalRef(pObject); |  | 
| 239 |  | 
| 240     AdblockPlus::AppInfo appInfo; |  | 
| 241     appInfo.name = "adblockplusandroid"; |  | 
| 242     appInfo.version = GetString(pEnv, version); |  | 
| 243     appInfo.application = "android"; |  | 
| 244     appInfo.applicationVersion = GetString(pEnv, sdkVersion); |  | 
| 245     appInfo.locale = GetString(pEnv, locale); |  | 
| 246     appInfo.developmentBuild = developmentBuild; |  | 
| 247 |  | 
| 248     D(D_INFO, "AppInfo: name=%s, version=%s, application=%s, applicationVersion=
     %s , locale=%s, developmentBuild=%s", |  | 
| 249       appInfo.name.c_str(), appInfo.version.c_str(), appInfo.application.c_str()
     , |  | 
| 250       appInfo.applicationVersion.c_str(), appInfo.locale.c_str(), |  | 
| 251       appInfo.developmentBuild ? "true" : "false"); |  | 
| 252 |  | 
| 253     AdblockPlus::JsEnginePtr jsEngine(AdblockPlus::JsEngine::New(appInfo)); |  | 
| 254 |  | 
| 255     AdblockPlus::DefaultFileSystem* defaultFileSystem = new AdblockPlus::Default
     FileSystem(); |  | 
| 256     AndroidLogSystem* androidLogSystem = new AndroidLogSystem(); |  | 
| 257     AndroidWebRequest* androidWebRequest = new AndroidWebRequest(globalJvm); |  | 
| 258 |  | 
| 259     defaultFileSystem->SetBasePath(GetString(pEnv, basePath)); |  | 
| 260     jsEngine->SetLogSystem(AdblockPlus::LogSystemPtr(androidLogSystem)); |  | 
| 261     jsEngine->SetFileSystem(AdblockPlus::FileSystemPtr(defaultFileSystem)); |  | 
| 262     jsEngine->SetWebRequest(AdblockPlus::WebRequestPtr(androidWebRequest)); |  | 
| 263     jsEngine->SetEventCallback("updateAvailable", std::tr1::bind(&UpdateAvailabl
     eCallback, std::tr1::placeholders::_1)); |  | 
| 264 |  | 
| 265     filterEngine = new AdblockPlus::FilterEngine(jsEngine); |  | 
| 266     filterEngine->SetFilterChangeCallback(&FilterChangedCallback); |  | 
| 267   } |  | 
| 268   catch (const std::exception& e) |  | 
| 269   { |  | 
| 270     ThrowJavaException(pEnv, e); |  | 
| 271   } |  | 
| 272   catch (...) |  | 
| 273   { |  | 
| 274     ThrowJavaException(pEnv); |  | 
| 275   } |  | 
| 276 } |  | 
| 277 |  | 
| 278 JNIEXPORT void JNICALL Java_org_adblockplus_android_ABPEngine_release(JNIEnv *pE
     nv, jobject) |  | 
| 279 { |  | 
| 280   D(D_WARN, "nativeRelease()"); |  | 
| 281   try |  | 
| 282   { |  | 
| 283     AdblockPlus::JsEnginePtr jsEngine = filterEngine->GetJsEngine(); |  | 
| 284     jsEngine->RemoveEventCallback("updateAvailable"); |  | 
| 285     filterEngine->RemoveFilterChangeCallback(); |  | 
| 286     delete filterEngine; |  | 
| 287     pEnv->DeleteGlobalRef(jniObject); |  | 
| 288     jniObject = NULL; |  | 
| 289     globalJvm = NULL; |  | 
| 290   } |  | 
| 291   catch (const std::exception& e) |  | 
| 292   { |  | 
| 293     ThrowJavaException(pEnv, e); |  | 
| 294   } |  | 
| 295   catch (...) |  | 
| 296   { |  | 
| 297     ThrowJavaException(pEnv); |  | 
| 298   } |  | 
| 299 } |  | 
| 300 |  | 
| 301 JNIEXPORT jboolean JNICALL Java_org_adblockplus_android_ABPEngine_isFirstRun(JNI
     Env *pEnv, jobject) |  | 
| 302 { |  | 
| 303   try |  | 
| 304   { |  | 
| 305     return filterEngine->IsFirstRun() ? JNI_TRUE : JNI_FALSE; |  | 
| 306   } |  | 
| 307   catch (const std::exception& e) |  | 
| 308   { |  | 
| 309     ThrowJavaException(pEnv, e); |  | 
| 310   } |  | 
| 311   catch (...) |  | 
| 312   { |  | 
| 313     ThrowJavaException(pEnv); |  | 
| 314   } |  | 
| 315   return JNI_FALSE; |  | 
| 316 } |  | 
| 317 |  | 
| 318 JNIEXPORT jobjectArray JNICALL Java_org_adblockplus_android_ABPEngine_getListedS
     ubscriptions(JNIEnv *pEnv, jobject) |  | 
| 319 { |  | 
| 320   D(D_WARN, "getListedSubscriptions()"); |  | 
| 321   try |  | 
| 322   { |  | 
| 323     const std::vector<AdblockPlus::SubscriptionPtr> subscriptions = filterEngine
     ->GetListedSubscriptions(); |  | 
| 324     return subscriptionsAsJavaArray(pEnv, subscriptions); |  | 
| 325   } |  | 
| 326   catch (const std::exception& e) |  | 
| 327   { |  | 
| 328     ThrowJavaException(pEnv, e); |  | 
| 329   } |  | 
| 330   catch (...) |  | 
| 331   { |  | 
| 332     ThrowJavaException(pEnv); |  | 
| 333   } |  | 
| 334   return 0; |  | 
| 335 } |  | 
| 336 |  | 
| 337 JNIEXPORT jobjectArray JNICALL Java_org_adblockplus_android_ABPEngine_getRecomme
     ndedSubscriptions(JNIEnv *pEnv, jobject) |  | 
| 338 { |  | 
| 339   D(D_WARN, "getRecommendedSubscriptions()"); |  | 
| 340   try |  | 
| 341   { |  | 
| 342     const std::vector<AdblockPlus::SubscriptionPtr> subscriptions = filterEngine
     ->FetchAvailableSubscriptions(); |  | 
| 343     return subscriptionsAsJavaArray(pEnv, subscriptions); |  | 
| 344   } |  | 
| 345   catch (const std::exception& e) |  | 
| 346   { |  | 
| 347     ThrowJavaException(pEnv, e); |  | 
| 348   } |  | 
| 349   catch (...) |  | 
| 350   { |  | 
| 351     ThrowJavaException(pEnv); |  | 
| 352   } |  | 
| 353   return 0; |  | 
| 354 } |  | 
| 355 |  | 
| 356 JNIEXPORT void JNICALL Java_org_adblockplus_android_ABPEngine_addSubscription(JN
     IEnv *pEnv, jobject, jstring url) |  | 
| 357 { |  | 
| 358   D(D_WARN, "addSubscription()"); |  | 
| 359   try |  | 
| 360   { |  | 
| 361     const std::string surl = GetString(pEnv, url); |  | 
| 362     AdblockPlus::SubscriptionPtr subscription = filterEngine->GetSubscription(su
     rl); |  | 
| 363     subscription->AddToList(); |  | 
| 364   } |  | 
| 365   catch (const std::exception& e) |  | 
| 366   { |  | 
| 367     ThrowJavaException(pEnv, e); |  | 
| 368   } |  | 
| 369   catch (...) |  | 
| 370   { |  | 
| 371     ThrowJavaException(pEnv); |  | 
| 372   } |  | 
| 373 } |  | 
| 374 |  | 
| 375 JNIEXPORT void JNICALL Java_org_adblockplus_android_ABPEngine_removeSubscription
     (JNIEnv *pEnv, jobject, jstring url) |  | 
| 376 { |  | 
| 377   D(D_WARN, "removeSubscription()"); |  | 
| 378   try |  | 
| 379   { |  | 
| 380     const std::string surl = GetString(pEnv, url); |  | 
| 381     AdblockPlus::SubscriptionPtr subscription = filterEngine->GetSubscription(su
     rl); |  | 
| 382     if (subscription->IsListed()) |  | 
| 383     { |  | 
| 384       subscription->RemoveFromList(); |  | 
| 385     } |  | 
| 386   } |  | 
| 387   catch (const std::exception& e) |  | 
| 388   { |  | 
| 389     ThrowJavaException(pEnv, e); |  | 
| 390   } |  | 
| 391   catch (...) |  | 
| 392   { |  | 
| 393     ThrowJavaException(pEnv); |  | 
| 394   } |  | 
| 395 } |  | 
| 396 |  | 
| 397 JNIEXPORT void JNICALL Java_org_adblockplus_android_ABPEngine_refreshSubscriptio
     n(JNIEnv *pEnv, jobject, jstring url) |  | 
| 398 { |  | 
| 399   D(D_WARN, "refreshSubscription()"); |  | 
| 400   try |  | 
| 401   { |  | 
| 402     const std::string surl = GetString(pEnv, url); |  | 
| 403     AdblockPlus::SubscriptionPtr subscription = filterEngine->GetSubscription(su
     rl); |  | 
| 404     subscription->UpdateFilters(); |  | 
| 405   } |  | 
| 406   catch (const std::exception& e) |  | 
| 407   { |  | 
| 408     ThrowJavaException(pEnv, e); |  | 
| 409   } |  | 
| 410   catch (...) |  | 
| 411   { |  | 
| 412     ThrowJavaException(pEnv); |  | 
| 413   } |  | 
| 414 } |  | 
| 415 |  | 
| 416 JNIEXPORT void JNICALL Java_org_adblockplus_android_ABPEngine_actualizeSubscript
     ionStatus(JNIEnv *pEnv, jobject, jstring url) |  | 
| 417 { |  | 
| 418   D(D_WARN, "actualizeSubscriptionStatus()"); |  | 
| 419   try |  | 
| 420   { |  | 
| 421     const std::string surl = GetString(pEnv, url); |  | 
| 422     AdblockPlus::SubscriptionPtr subscription = filterEngine->GetSubscription(su
     rl); |  | 
| 423     UpdateSubscriptionStatus(subscription); |  | 
| 424   } |  | 
| 425   catch (const std::exception& e) |  | 
| 426   { |  | 
| 427     ThrowJavaException(pEnv, e); |  | 
| 428   } |  | 
| 429   catch (...) |  | 
| 430   { |  | 
| 431     ThrowJavaException(pEnv); |  | 
| 432   } |  | 
| 433 } |  | 
| 434 |  | 
| 435 JNIEXPORT void JNICALL Java_org_adblockplus_android_ABPEngine_setAcceptableAdsEn
     abled(JNIEnv *pEnv, jobject, jboolean enabled) |  | 
| 436 { |  | 
| 437   D(D_WARN, "setAcceptableAdsEnabled()"); |  | 
| 438   try |  | 
| 439   { |  | 
| 440     const std::string surl = filterEngine->GetPref("subscriptions_exceptionsurl"
     )->AsString(); |  | 
| 441     AdblockPlus::SubscriptionPtr subscription = filterEngine->GetSubscription(su
     rl); |  | 
| 442     if (enabled == JNI_TRUE) |  | 
| 443     { |  | 
| 444       subscription->AddToList(); |  | 
| 445     } |  | 
| 446     else if (subscription->IsListed()) |  | 
| 447     { |  | 
| 448       subscription->RemoveFromList(); |  | 
| 449     } |  | 
| 450   } |  | 
| 451   catch (const std::exception& e) |  | 
| 452   { |  | 
| 453     ThrowJavaException(pEnv, e); |  | 
| 454   } |  | 
| 455   catch (...) |  | 
| 456   { |  | 
| 457     ThrowJavaException(pEnv); |  | 
| 458   } |  | 
| 459 } |  | 
| 460 |  | 
| 461 JNIEXPORT jstring JNICALL Java_org_adblockplus_android_ABPEngine_getDocumentatio
     nLink( |  | 
| 462     JNIEnv *env, jobject object) |  | 
| 463 { |  | 
| 464   const std::string documentationLink = filterEngine->GetPref("documentation_lin
     k")->AsString(); |  | 
| 465   return env->NewStringUTF(documentationLink.c_str()); |  | 
| 466 } |  | 
| 467 |  | 
| 468 JNIEXPORT jboolean JNICALL Java_org_adblockplus_android_ABPEngine_matches( |  | 
| 469   JNIEnv *pEnv, jobject, jstring url, jstring contentType, jobjectArray document
     Urls) |  | 
| 470 { |  | 
| 471   try |  | 
| 472   { |  | 
| 473     const std::string surl = GetString(pEnv, url); |  | 
| 474     const std::string stype = GetString(pEnv, contentType); |  | 
| 475     const int documentUrlsLength = pEnv->GetArrayLength(documentUrls); |  | 
| 476     std::vector<std::string> sdocumentUrls; |  | 
| 477     for(int i = 0; i < documentUrlsLength; i++) |  | 
| 478     { |  | 
| 479        jstring documentUrl = static_cast<jstring>(pEnv->GetObjectArrayElement(do
     cumentUrls, i)); |  | 
| 480        sdocumentUrls.push_back(GetString(pEnv, documentUrl)); |  | 
| 481     } |  | 
| 482 |  | 
| 483     AdblockPlus::FilterPtr filter = filterEngine->Matches(surl, stype, sdocument
     Urls); |  | 
| 484 |  | 
| 485     if (! filter) |  | 
| 486       return JNI_FALSE; |  | 
| 487 |  | 
| 488     // hack: if there is no referrer, block only if filter is domain-specific |  | 
| 489     // (to re-enable in-app ads blocking, proposed on 12.11.2012 Monday meeting) |  | 
| 490     // (documentUrls contains the referrers on Android) |  | 
| 491     if (!sdocumentUrls.size() && |  | 
| 492         (filter->GetProperty("text")->AsString()).find("||") != std::string::npo
     s) |  | 
| 493       return JNI_FALSE; |  | 
| 494 |  | 
| 495     return filter->GetType() == AdblockPlus::Filter::TYPE_EXCEPTION ? JNI_FALSE 
     : JNI_TRUE; |  | 
| 496   } |  | 
| 497   catch (const std::exception& e) |  | 
| 498   { |  | 
| 499     ThrowJavaException(pEnv, e); |  | 
| 500   } |  | 
| 501   catch (...) |  | 
| 502   { |  | 
| 503     ThrowJavaException(pEnv); |  | 
| 504   } |  | 
| 505   return JNI_FALSE; |  | 
| 506 } |  | 
| 507 |  | 
| 508 JNIEXPORT jobjectArray JNICALL Java_org_adblockplus_android_ABPEngine_getSelecto
     rsForDomain(JNIEnv *pEnv, jobject, jstring domain) |  | 
| 509 { |  | 
| 510   try |  | 
| 511   { |  | 
| 512     const std::string sdomain = GetString(pEnv, domain); |  | 
| 513     const std::vector<std::string> selectors = filterEngine->GetElementHidingSel
     ectors(sdomain); |  | 
| 514 |  | 
| 515     static jclass cls = reinterpret_cast<jclass>(pEnv->NewGlobalRef(pEnv->FindCl
     ass("java/lang/String"))); |  | 
| 516 |  | 
| 517     D(D_WARN, "Selectors: %d", selectors.size()); |  | 
| 518     const jobjectArray ret = (jobjectArray) pEnv->NewObjectArray(selectors.size(
     ), cls, NULL); |  | 
| 519 |  | 
| 520     int i = 0; |  | 
| 521     for (std::vector<std::string>::const_iterator it = selectors.begin(); |  | 
| 522          it != selectors.end(); it++) |  | 
| 523     { |  | 
| 524       jstring selector = pEnv->NewStringUTF((*it).c_str()); |  | 
| 525       pEnv->SetObjectArrayElement(ret, i, selector); |  | 
| 526       pEnv->DeleteLocalRef(selector); |  | 
| 527       i++; |  | 
| 528     } |  | 
| 529 |  | 
| 530     return ret; |  | 
| 531   } |  | 
| 532   catch (const std::exception& e) |  | 
| 533   { |  | 
| 534     ThrowJavaException(pEnv, e); |  | 
| 535   } |  | 
| 536   catch (...) |  | 
| 537   { |  | 
| 538     ThrowJavaException(pEnv); |  | 
| 539   } |  | 
| 540   return 0; |  | 
| 541 } |  | 
| 542 |  | 
| 543 JNIEXPORT void JNICALL Java_org_adblockplus_android_ABPEngine_checkUpdates(JNIEn
     v *pEnv, jobject) |  | 
| 544 { |  | 
| 545   try |  | 
| 546   { |  | 
| 547     manualUpdate = true; |  | 
| 548     filterEngine->ForceUpdateCheck(UpdaterCallback); |  | 
| 549   } |  | 
| 550   catch (const std::exception& e) |  | 
| 551   { |  | 
| 552     ThrowJavaException(pEnv, e); |  | 
| 553   } |  | 
| 554   catch (...) |  | 
| 555   { |  | 
| 556     ThrowJavaException(pEnv); |  | 
| 557   } |  | 
| 558 } |  | 
| OLD | NEW | 
|---|