Rietveld Code Review Tool
Help | Bug tracker | Discussion group | Source code
Issues
All Issues

Side by Side Diff: jni/JniFilterEngine.cpp

Issue 29345540: Issue 4030 - Move JNI bindings into separate library project (Closed)
Patch Set: Changeset in adblockplusandroid repo Created July 22, 2016, 12:10 p.m.
Left:
Right:
Use n/p to move between diff chunks; N/P to move between comments.
Jump to:
View unified diff | Download patch
« dependencies ('K') | « jni/JniFilterChangeCallback.cpp ('k') | jni/JniJsEngine.cpp » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 /*
2 * This file is part of Adblock Plus <https://adblockplus.org/>,
3 * Copyright (C) 2006-2016 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 <AdblockPlus.h>
19 #include "Utils.h"
20 #include "JniCallbacks.h"
21
22 static jobject SubscriptionsToArrayList(JNIEnv* env, std::vector<AdblockPlus::Su bscriptionPtr>& subscriptions)
23 {
24 jobject list = NewJniArrayList(env);
25
26 for (std::vector<AdblockPlus::SubscriptionPtr>::iterator it = subscriptions.be gin(), end = subscriptions.end(); it != end; it++)
27 {
28 JniAddObjectToList(env, list, NewJniSubscription(env, *it));
29 }
30
31 return list;
32 }
33
34 static AdblockPlus::FilterEngine::ContentType ConvertContentType(JNIEnv *env,
35 jobject jContentType)
36 {
37 JniLocalReference<jclass> contentTypeClass(env,
38 env->GetObjectClass(jContentType));
39 jmethodID nameMethod = env->GetMethodID(*contentTypeClass, "name",
40 "()Ljava/lang/String;");
41 JniLocalReference<jstring> jValue(env,
42 (jstring) env->CallObjectMethod(jContentType, nameMethod));
43 const std::string value = JniJavaToStdString(env, *jValue);
44 return AdblockPlus::FilterEngine::StringToContentType(value);
45 }
46
47 static jlong JNICALL JniCtor(JNIEnv* env, jclass clazz, jlong enginePtr)
48 {
49 try
50 {
51 AdblockPlus::JsEnginePtr& jsEngine = *JniLongToTypePtr<AdblockPlus::JsEngine Ptr>(enginePtr);
52 return JniPtrToLong(new AdblockPlus::FilterEngine(jsEngine));
53 }
54 CATCH_THROW_AND_RETURN(env, 0)
55 }
56
57 static void JNICALL JniDtor(JNIEnv* env, jclass clazz, jlong ptr)
58 {
59 delete JniLongToTypePtr<AdblockPlus::FilterEngine>(ptr);
60 }
61
62 static jboolean JNICALL JniIsFirstRun(JNIEnv* env, jclass clazz, jlong ptr)
63 {
64 try
65 {
66 AdblockPlus::FilterEngine* engine = JniLongToTypePtr<AdblockPlus::FilterEngi ne>(ptr);
67
68 return engine->IsFirstRun() ? JNI_TRUE : JNI_FALSE;
69 }
70 CATCH_THROW_AND_RETURN(env, JNI_FALSE);
71 }
72
73 static jobject JNICALL JniGetFilter(JNIEnv* env, jclass clazz, jlong ptr, jstrin g jText)
74 {
75 AdblockPlus::FilterEngine* engine = JniLongToTypePtr<AdblockPlus::FilterEngine >(ptr);
76 std::string text = JniJavaToStdString(env, jText);
77
78 try
79 {
80 AdblockPlus::FilterPtr filter = engine->GetFilter(text);
81
82 return NewJniFilter(env, filter);
83 }
84 CATCH_THROW_AND_RETURN(env, 0);
85 }
86
87 static jobject JNICALL JniGetListedFilters(JNIEnv* env, jclass clazz, jlong ptr)
88 {
89 AdblockPlus::FilterEngine* engine = JniLongToTypePtr<AdblockPlus::FilterEngine >(ptr);
90
91 try
92 {
93 std::vector<AdblockPlus::FilterPtr> filters = engine->GetListedFilters();
94
95 jobject list = NewJniArrayList(env);
96
97 for (std::vector<AdblockPlus::FilterPtr>::iterator it = filters.begin(), end = filters.end(); it != end; it++)
98 {
99 JniAddObjectToList(env, list, *JniLocalReference<jobject>(env, NewJniFilte r(env, *it)));
100 }
101
102 return list;
103 }
104 CATCH_THROW_AND_RETURN(env, 0);
105 }
106
107 static jobject JNICALL JniGetSubscription(JNIEnv* env, jclass clazz, jlong ptr, jstring jUrl)
108 {
109 AdblockPlus::FilterEngine* engine = JniLongToTypePtr<AdblockPlus::FilterEngine >(ptr);
110 std::string url = JniJavaToStdString(env, jUrl);
111
112 try
113 {
114 AdblockPlus::SubscriptionPtr subscription = engine->GetSubscription(url);
115
116 return NewJniSubscription(env, subscription);
117 }
118 CATCH_THROW_AND_RETURN(env, 0);
119 }
120
121 static void JNICALL JniShowNextNotification(JNIEnv* env, jclass clazz, jlong ptr , jstring jUrl)
122 {
123 AdblockPlus::FilterEngine* engine = JniLongToTypePtr<AdblockPlus::FilterEngine >(ptr);
124 std::string url = JniJavaToStdString(env, jUrl);
125
126 try
127 {
128 engine->ShowNextNotification(url);
129 }
130 CATCH_AND_THROW(env);
131 }
132
133 static void JNICALL JniSetShowNotificationCallback(JNIEnv* env, jclass clazz,
134 jlong ptr, jlong callbackPtr)
135 {
136 AdblockPlus::FilterEngine* const engine =
137 JniLongToTypePtr<AdblockPlus::FilterEngine>(ptr);
138 JniShowNotificationCallback* const callback =
139 JniLongToTypePtr<JniShowNotificationCallback>(callbackPtr);
140 AdblockPlus::FilterEngine::ShowNotificationCallback showNotificationCallback =
141 std::bind(&JniShowNotificationCallback::Callback, callback,
142 std::placeholders::_1);
143 try
144 {
145 engine->SetShowNotificationCallback(showNotificationCallback);
146 }
147 CATCH_AND_THROW(env)
148 }
149
150 static void JNICALL JniRemoveShowNotificationCallback(JNIEnv* env, jclass clazz, jlong ptr)
151 {
152 AdblockPlus::FilterEngine* engine = JniLongToTypePtr<AdblockPlus::FilterEngine >(ptr);
153
154 try
155 {
156 engine->RemoveShowNotificationCallback();
157 }
158 CATCH_AND_THROW(env);
159 }
160
161 static jobject JNICALL JniGetListedSubscriptions(JNIEnv* env, jclass clazz, jlon g ptr)
162 {
163 AdblockPlus::FilterEngine* engine = JniLongToTypePtr<AdblockPlus::FilterEngine >(ptr);
164
165 try
166 {
167 std::vector<AdblockPlus::SubscriptionPtr> subscriptions = engine->GetListedS ubscriptions();
168
169 return SubscriptionsToArrayList(env, subscriptions);
170 }
171 CATCH_THROW_AND_RETURN(env, 0);
172 }
173
174 static jobject JNICALL JniFetchAvailableSubscriptions(JNIEnv* env, jclass clazz, jlong ptr)
175 {
176 AdblockPlus::FilterEngine* engine = JniLongToTypePtr<AdblockPlus::FilterEngine >(ptr);
177
178 try
179 {
180 std::vector<AdblockPlus::SubscriptionPtr> subscriptions = engine->FetchAvail ableSubscriptions();
181
182 return SubscriptionsToArrayList(env, subscriptions);
183 }
184 CATCH_THROW_AND_RETURN(env, 0);
185 }
186
187 static void JNICALL JniRemoveUpdateAvailableCallback(JNIEnv* env, jclass clazz,
188 jlong ptr)
189 {
190 AdblockPlus::FilterEngine* const engine =
191 JniLongToTypePtr<AdblockPlus::FilterEngine>(ptr);
192 try
193 {
194 engine->RemoveUpdateAvailableCallback();
195 }
196 CATCH_AND_THROW(env)
197 }
198
199 static void JNICALL JniSetUpdateAvailableCallback(JNIEnv* env, jclass clazz,
200 jlong ptr, jlong callbackPtr)
201 {
202 AdblockPlus::FilterEngine* const engine =
203 JniLongToTypePtr<AdblockPlus::FilterEngine>(ptr);
204 JniUpdateAvailableCallback* const callback =
205 JniLongToTypePtr<JniUpdateAvailableCallback>(callbackPtr);
206 AdblockPlus::FilterEngine::UpdateAvailableCallback updateAvailableCallback =
207 std::bind(&JniUpdateAvailableCallback::Callback, callback,
208 std::placeholders::_1);
209 try
210 {
211 engine->SetUpdateAvailableCallback(updateAvailableCallback);
212 }
213 CATCH_AND_THROW(env)
214 }
215
216 static void JNICALL JniRemoveFilterChangeCallback(JNIEnv* env, jclass clazz, jlo ng ptr)
217 {
218 AdblockPlus::FilterEngine* engine = JniLongToTypePtr<AdblockPlus::FilterEngine >(ptr);
219
220 try
221 {
222 engine->RemoveFilterChangeCallback();
223 }
224 CATCH_AND_THROW(env)
225 }
226
227 static void JNICALL JniSetFilterChangeCallback(JNIEnv* env, jclass clazz,
228 jlong ptr, jlong filterPtr)
229 {
230 AdblockPlus::FilterEngine* engine =
231 JniLongToTypePtr<AdblockPlus::FilterEngine>(ptr);
232 JniFilterChangeCallback* callback = JniLongToTypePtr<JniFilterChangeCallback>(
233 filterPtr);
234
235 AdblockPlus::FilterEngine::FilterChangeCallback filterCallback =
236 std::bind(&JniFilterChangeCallback::Callback, callback,
237 std::placeholders::_1, std::placeholders::_2);
238
239 try
240 {
241 engine->SetFilterChangeCallback(filterCallback);
242 }
243 CATCH_AND_THROW(env)
244 }
245
246 static void JNICALL JniForceUpdateCheck(JNIEnv* env, jclass clazz, jlong ptr, jl ong updaterPtr)
247 {
248 AdblockPlus::FilterEngine* engine = JniLongToTypePtr<AdblockPlus::FilterEngine >(ptr);
249 JniUpdateCheckDoneCallback* callback =
250 JniLongToTypePtr<JniUpdateCheckDoneCallback>(updaterPtr);
251
252 AdblockPlus::FilterEngine::UpdateCheckDoneCallback
253 updateCheckDoneCallback = 0;
254
255 if (updaterPtr)
256 {
257 updateCheckDoneCallback =
258 std::bind(&JniUpdateCheckDoneCallback::Callback, callback,
259 std::placeholders::_1);
260 }
261
262 try
263 {
264 engine->ForceUpdateCheck(updateCheckDoneCallback);
265 }
266 CATCH_AND_THROW(env)
267 }
268
269 static jobject JNICALL JniGetElementHidingSelectors(JNIEnv* env, jclass clazz,
270 jlong ptr, jstring jDomain)
271 {
272 AdblockPlus::FilterEngine* engine =
273 JniLongToTypePtr<AdblockPlus::FilterEngine>(ptr);
274
275 std::string domain = JniJavaToStdString(env, jDomain);
276
277 try
278 {
279 std::vector<std::string> selectors = engine->GetElementHidingSelectors(
280 domain);
281
282 jobject list = NewJniArrayList(env);
283
284 for (std::vector<std::string>::iterator it = selectors.begin(), end =
285 selectors.end(); it != end; it++)
286 {
287 JniAddObjectToList(env, list,
288 *JniLocalReference<jstring>(env, env->NewStringUTF(it->c_str())));
289 }
290
291 return list;
292 }
293 CATCH_THROW_AND_RETURN(env, 0)
294 }
295
296 static jobject JNICALL JniMatches(JNIEnv* env, jclass clazz, jlong ptr, jstring jUrl, jobject jContentType, jstring jDocumentUrl)
297 {
298 AdblockPlus::FilterEngine* engine = JniLongToTypePtr<AdblockPlus::FilterEngine >(ptr);
299
300 std::string url = JniJavaToStdString(env, jUrl);
301 AdblockPlus::FilterEngine::ContentType contentType =
302 ConvertContentType(env, jContentType);
303 std::string documentUrl = JniJavaToStdString(env, jDocumentUrl);
304
305 try
306 {
307 AdblockPlus::FilterPtr filter = engine->Matches(url, contentType, documentUr l);
308
309 return NewJniFilter(env, filter);
310 }
311 CATCH_THROW_AND_RETURN(env, 0)
312 }
313
314 static void JavaStringArrayToStringVector(JNIEnv* env, jobjectArray jArray,
315 std::vector<std::string>& out)
316 {
317 if (jArray)
318 {
319 jsize len = env->GetArrayLength(jArray);
320
321 for (jsize i = 0; i < len; i++)
322 {
323 out.push_back(
324 JniJavaToStdString(env,
325 *JniLocalReference<jstring>(env,
326 static_cast<jstring>(
327 env->GetObjectArrayElement(jArray, i)))));
328 }
329 }
330 }
331
332 static jobject JNICALL JniMatchesMany(JNIEnv* env, jclass clazz, jlong ptr,
333 jstring jUrl, jobject jContentType, jobjectArray jDocumentUrls)
334 {
335 AdblockPlus::FilterEngine* engine =
336 JniLongToTypePtr<AdblockPlus::FilterEngine>(ptr);
337
338 std::string url = JniJavaToStdString(env, jUrl);
339 AdblockPlus::FilterEngine::ContentType contentType =
340 ConvertContentType(env, jContentType);
341
342 std::vector<std::string> documentUrls;
343 JavaStringArrayToStringVector(env, jDocumentUrls, documentUrls);
344
345 try
346 {
347 AdblockPlus::FilterPtr filter = engine->Matches(url, contentType,
348 documentUrls);
349
350 return NewJniFilter(env, filter);
351 }
352 CATCH_THROW_AND_RETURN(env, 0)
353 }
354
355 static jboolean JNICALL JniIsDocumentWhitelisted(JNIEnv* env, jclass clazz, jlon g ptr,
356 jstring jUrl, jobjectArray jDocumentUrls)
357 {
358 AdblockPlus::FilterEngine* engine =
359 JniLongToTypePtr<AdblockPlus::FilterEngine>(ptr);
360
361 std::string url = JniJavaToStdString(env, jUrl);
362 std::vector<std::string> documentUrls;
363 JavaStringArrayToStringVector(env, jDocumentUrls, documentUrls);
364 try
365 {
366 return engine->IsDocumentWhitelisted(url, documentUrls) ?
367 JNI_TRUE : JNI_FALSE;
368 }
369 CATCH_THROW_AND_RETURN(env, JNI_FALSE)
370 }
371
372 static jboolean JNICALL JniIsElemhideWhitelisted(JNIEnv* env, jclass clazz, jlon g ptr,
373 jstring jUrl, jobjectArray jDocumentUrls)
374 {
375 AdblockPlus::FilterEngine* engine =
376 JniLongToTypePtr<AdblockPlus::FilterEngine>(ptr);
377
378 std::string url = JniJavaToStdString(env, jUrl);
379 std::vector<std::string> documentUrls;
380 JavaStringArrayToStringVector(env, jDocumentUrls, documentUrls);
381 try
382 {
383 return engine->IsElemhideWhitelisted(url, documentUrls) ?
384 JNI_TRUE : JNI_FALSE;
385 }
386 CATCH_THROW_AND_RETURN(env, JNI_FALSE)
387 }
388
389 static jobject JNICALL JniGetPref(JNIEnv* env, jclass clazz, jlong ptr, jstring jPref)
390 {
391 AdblockPlus::FilterEngine* engine = JniLongToTypePtr < AdblockPlus::FilterEngi ne > (ptr);
392
393 std::string pref = JniJavaToStdString(env, jPref);
394
395 try
396 {
397 AdblockPlus::JsValuePtr value = engine->GetPref(pref);
398
399 return NewJniJsValue(env, value);
400 }
401 CATCH_THROW_AND_RETURN(env, 0)
402 }
403
404 static void JNICALL JniSetPref(JNIEnv* env, jclass clazz, jlong ptr, jstring jPr ef, jlong jsValue)
405 {
406 AdblockPlus::FilterEngine* engine = JniLongToTypePtr<AdblockPlus::FilterEngine >(ptr);
407
408 std::string pref = JniJavaToStdString(env, jPref);
409 AdblockPlus::JsValuePtr value = JniGetJsValuePtr(jsValue);
410
411 try
412 {
413 engine->SetPref(pref, value);
414 }
415 CATCH_AND_THROW(env)
416 }
417
418 static JNINativeMethod methods[] =
419 {
420 { (char*)"ctor", (char*)"(J)J", (void*)JniCtor },
421 { (char*)"isFirstRun", (char*)"(J)Z", (void*)JniIsFirstRun },
422 { (char*)"getFilter", (char*)"(JLjava/lang/String;)" TYP("Filter"), (void*)Jni GetFilter },
423 { (char*)"getListedFilters", (char*)"(J)Ljava/util/List;", (void*)JniGetListed Filters },
424 { (char*)"getSubscription", (char*)"(JLjava/lang/String;)" TYP("Subscription") , (void*)JniGetSubscription },
425 { (char*)"showNextNotification", (char*)"(JLjava/lang/String;)V", (void*)JniSh owNextNotification },
426 { (char*)"setShowNotificationCallback", (char*)"(JJ)V", (void*)JniSetShowNotif icationCallback },
427 { (char*)"removeShowNotificationCallback", (char*)"(J)V", (void*)JniRemoveShow NotificationCallback },
428 { (char*)"getListedSubscriptions", (char*)"(J)Ljava/util/List;", (void*)JniGet ListedSubscriptions },
429 { (char*)"fetchAvailableSubscriptions", (char*)"(J)Ljava/util/List;", (void*)J niFetchAvailableSubscriptions },
430 { (char*)"setUpdateAvailableCallback", (char*)"(JJ)V", (void*)JniSetUpdateAvai lableCallback },
431 { (char*)"removeUpdateAvailableCallback", (char*)"(J)V", (void*)JniRemoveUpdat eAvailableCallback },
432 { (char*)"setFilterChangeCallback", (char*)"(JJ)V", (void*)JniSetFilterChangeC allback },
433 { (char*)"removeFilterChangeCallback", (char*)"(J)V", (void*)JniRemoveFilterCh angeCallback },
434 { (char*)"forceUpdateCheck", (char*)"(JJ)V", (void*)JniForceUpdateCheck },
435 { (char*)"getElementHidingSelectors", (char*)"(JLjava/lang/String;)Ljava/util/ List;", (void*)JniGetElementHidingSelectors },
436 { (char*)"matches", (char*)"(JLjava/lang/String;" TYP("FilterEngine$ContentTyp e") "Ljava/lang/String;)" TYP("Filter"), (void*)JniMatches },
437 { (char*)"matches", (char*)"(JLjava/lang/String;" TYP("FilterEngine$ContentTyp e") "[Ljava/lang/String;)" TYP("Filter"), (void*)JniMatchesMany },
438 { (char*)"isDocumentWhitelisted", (char*)"(JLjava/lang/String;[Ljava/lang/Stri ng;)Z", (void*)JniIsDocumentWhitelisted },
439 { (char*)"isElemhideWhitelisted", (char*)"(JLjava/lang/String;[Ljava/lang/Stri ng;)Z", (void*)JniIsElemhideWhitelisted },
440 { (char*)"getPref", (char*)"(JLjava/lang/String;)" TYP("JsValue"), (void*)JniG etPref },
441 { (char*)"setPref", (char*)"(JLjava/lang/String;J)V", (void*)JniSetPref },
442 { (char*)"dtor", (char*)"(J)V", (void*)JniDtor }
443 };
444
445 extern "C" JNIEXPORT void JNICALL Java_org_adblockplus_libadblockplus_FilterEngi ne_registerNatives(JNIEnv *env, jclass clazz)
446 {
447 env->RegisterNatives(clazz, methods, sizeof(methods) / sizeof(methods[0]));
448 }
OLDNEW
« dependencies ('K') | « jni/JniFilterChangeCallback.cpp ('k') | jni/JniJsEngine.cpp » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld